eoapi-cdk 11.4.1 → 11.6.0

package/lib/lambda-api-gateway/index.js

@@ -24,5 +24,5 @@ class LambdaApiGateway extends constructs_1.Construct {
 }
 exports.LambdaApiGateway = LambdaApiGateway;
 _a = JSII_RTTI_SYMBOL_1;
-LambdaApiGateway[_a] = { fqn: "eoapi-cdk.LambdaApiGateway", version: "11.4.1" };
+LambdaApiGateway[_a] = { fqn: "eoapi-cdk.LambdaApiGateway", version: "11.6.0" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/lambda-api-gateway-private/index.js

@@ -52,5 +52,5 @@ class PrivateLambdaApiGateway extends constructs_1.Construct {
 }
 exports.PrivateLambdaApiGateway = PrivateLambdaApiGateway;
 _a = JSII_RTTI_SYMBOL_1;
-PrivateLambdaApiGateway[_a] = { fqn: "eoapi-cdk.PrivateLambdaApiGateway", version: "11.4.1" };
+PrivateLambdaApiGateway[_a] = { fqn: "eoapi-cdk.PrivateLambdaApiGateway", version: "11.6.0" };
 //# sourceMappingURL=data:application/json;base64,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

package/lib/stac-api/index.js

@@ -81,7 +81,7 @@ class PgStacApiLambdaRuntime extends constructs_1.Construct {
 }
 exports.PgStacApiLambdaRuntime = PgStacApiLambdaRuntime;
 _a = JSII_RTTI_SYMBOL_1;
-PgStacApiLambdaRuntime[_a] = { fqn: "eoapi-cdk.PgStacApiLambdaRuntime", version: "11.4.1" };
+PgStacApiLambdaRuntime[_a] = { fqn: "eoapi-cdk.PgStacApiLambdaRuntime", version: "11.6.0" };
 class PgStacApiLambda extends constructs_1.Construct {
     constructor(scope, id, props) {
         super(scope, id);
@@ -120,5 +120,5 @@ class PgStacApiLambda extends constructs_1.Construct {
 }
 exports.PgStacApiLambda = PgStacApiLambda;
 _b = JSII_RTTI_SYMBOL_1;
-PgStacApiLambda[_b] = { fqn: "eoapi-cdk.PgStacApiLambda", version: "11.4.1" };
+PgStacApiLambda[_b] = { fqn: "eoapi-cdk.PgStacApiLambda", version: "11.6.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_apigatewayv2 as apigatewayv2,\n  aws_logs,\n  CfnOutput,\n  Duration,\n  aws_ec2 as ec2,\n  aws_lambda as lambda,\n  aws_rds as rds,\n  aws_secretsmanager as secretsmanager,\n  Stack,\n} from \"aws-cdk-lib\";\nimport { Construct } from \"constructs\";\nimport * as path from \"path\";\nimport { LambdaApiGateway } from \"../lambda-api-gateway\";\nimport {\n  CustomLambdaFunctionProps,\n  resolveLambdaCode,\n  extractDatabaseDependencies,\n  createLambdaVersionWithDependencies,\n} from \"../utils\";\n\nexport const EXTENSIONS = {\n  QUERY: \"query\",\n  SORT: \"sort\",\n  FIELDS: \"fields\",\n  FILTER: \"filter\",\n  FREE_TEXT: \"free_text\",\n  PAGINATION: \"pagination\",\n  COLLECTION_SEARCH: \"collection_search\",\n  TRANSACTION: \"transaction\",\n  BULK_TRANSACTION: \"bulk_transactions\",\n} as const;\n\ntype ExtensionType = (typeof EXTENSIONS)[keyof typeof EXTENSIONS];\n\n/**\n * Validates if a given string is a valid STAC extension\n */\nfunction isValidExtension(value: string): value is ExtensionType {\n  return Object.values(EXTENSIONS).includes(value as any);\n}\n\nexport class PgStacApiLambdaRuntime extends Construct {\n  public readonly lambdaFunction: lambda.Function;\n\n  constructor(\n    scope: Construct,\n    id: string,\n    props: PgStacApiLambdaRuntimeProps,\n  ) {\n    super(scope, id);\n\n    const defaultExtensions: ExtensionType[] = [\n      EXTENSIONS.QUERY,\n      EXTENSIONS.SORT,\n      EXTENSIONS.FIELDS,\n      EXTENSIONS.FILTER,\n      EXTENSIONS.FREE_TEXT,\n      EXTENSIONS.PAGINATION,\n      EXTENSIONS.COLLECTION_SEARCH,\n    ];\n\n    if (props.enabledExtensions) {\n      for (const ext of props.enabledExtensions) {\n        if (!isValidExtension(ext)) {\n          throw new Error(\n            `Invalid extension: \"${ext}\". Must be one of: ${Object.values(\n              EXTENSIONS,\n            ).join(\", \")}`,\n          );\n        }\n      }\n    }\n\n    const enabledExtensions = props.enabledExtensions || defaultExtensions;\n\n    const { code: userCode, ...otherLambdaOptions } =\n      props.lambdaFunctionOptions || {};\n\n    this.lambdaFunction = new lambda.Function(this, \"lambda\", {\n      // defaults\n      runtime: lambda.Runtime.PYTHON_3_12,\n      handler: \"stac_api.handler.handler\",\n      memorySize: 8192,\n      logRetention: aws_logs.RetentionDays.ONE_WEEK,\n      timeout: Duration.seconds(30),\n      code: resolveLambdaCode(userCode, path.join(__dirname, \"..\"), {\n        file: \"stac-api/runtime/Dockerfile\",\n        buildArgs: { PYTHON_VERSION: \"3.12\" },\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: \"0\",\n        DB_MAX_CONN_SIZE: \"1\",\n        ENABLED_EXTENSIONS: enabledExtensions.join(\",\"),\n        ...props.apiEnv,\n      },\n      snapStart: props.enableSnapStart\n        ? lambda.SnapStartConf.ON_PUBLISHED_VERSIONS\n        : undefined,\n      // overwrites defaults with user-provided configurable properties (excluding code)\n      ...otherLambdaOptions,\n    });\n\n    props.dbSecret.grantRead(this.lambdaFunction);\n\n    if (props.vpc) {\n      this.lambdaFunction.connections.allowTo(\n        props.db,\n        ec2.Port.tcp(5432),\n        \"allow connections from stac-fastapi-pgstac\",\n      );\n    }\n  }\n}\n\nexport interface PgStacApiLambdaRuntimeProps {\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 fastapi-pgstac runtime.\n   */\n  readonly apiEnv?: Record<string, string>;\n\n  /**\n   * List of STAC API extensions to enable.\n   *\n   * @default - query, sort, fields, filter, free_text, pagination, collection_search\n   */\n  readonly enabledExtensions?: ExtensionType[];\n\n  /**\n   * Enable SnapStart to reduce cold start latency.\n   *\n   * SnapStart creates a snapshot of the initialized Lambda function, allowing new instances\n   * to start from this pre-initialized state instead of starting from scratch.\n   *\n   * Benefits:\n   * - Significantly reduces cold start times (typically 10x faster)\n   * - Improves API response time for infrequent requests\n   *\n   * Considerations:\n   * - Additional cost: charges for snapshot storage and restore operations\n   * - Requires Lambda versioning (automatically configured by this construct)\n   * - Database connections are recreated on restore using snapshot lifecycle hooks\n   *\n   * @see https://docs.aws.amazon.com/lambda/latest/dg/snapstart.html\n   * @default false\n   */\n  readonly enableSnapStart?: boolean;\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\nexport class PgStacApiLambda extends Construct {\n  /**\n   * URL for the STAC API.\n   */\n  readonly url: string;\n\n  /**\n   * Lambda function for the STAC API.\n   */\n  readonly lambdaFunction: lambda.Function;\n\n  /**\n   * @deprecated - use lambdaFunction instead\n   */\n  public stacApiLambdaFunction: lambda.Function;\n\n  constructor(scope: Construct, id: string, props: PgStacApiLambdaProps) {\n    super(scope, id);\n\n    const runtime = new PgStacApiLambdaRuntime(this, \"runtime\", {\n      vpc: props.vpc,\n      subnetSelection: props.subnetSelection,\n      db: props.db,\n      dbSecret: props.dbSecret,\n      enabledExtensions: props.enabledExtensions,\n      apiEnv: props.apiEnv,\n      enableSnapStart: props.enableSnapStart,\n      lambdaFunctionOptions: props.lambdaFunctionOptions,\n    });\n    this.stacApiLambdaFunction = this.lambdaFunction = runtime.lambdaFunction;\n\n    // Determine which lambda to use for API Gateway\n    let apiLambda: lambda.Function | lambda.Version;\n    if (props.enableSnapStart) {\n      // Extract dependencies from database if it's a PgStacDatabase with PgBouncer\n      const dbDependencies = extractDatabaseDependencies(props.db);\n\n      // Create version with dependencies to ensure snapshot creation waits\n      apiLambda = createLambdaVersionWithDependencies(\n        runtime.lambdaFunction,\n        dbDependencies,\n      );\n    } else {\n      apiLambda = runtime.lambdaFunction;\n    }\n\n    const { api } = new LambdaApiGateway(this, \"stac-api\", {\n      lambdaFunction: apiLambda,\n      domainName: props.domainName ?? props.stacApiDomainName,\n    });\n\n    this.url = api.url!;\n\n    new CfnOutput(this, \"stac-api-output\", {\n      exportName: `${Stack.of(this).stackName}-url`,\n      value: this.url,\n    });\n  }\n}\n\nexport interface PgStacApiLambdaProps extends PgStacApiLambdaRuntimeProps {\n  /**\n   * Domain Name for the STAC API. If defined, will create the domain name and integrate it with the STAC API.\n   *\n   * @default - undefined\n   */\n  readonly domainName?: apigatewayv2.IDomainName;\n\n  /**\n   * Custom Domain Name Options for STAC API.\n   *\n   * @deprecated Use 'domainName' instead.\n   * @default - undefined.\n   */\n  readonly stacApiDomainName?: apigatewayv2.IDomainName;\n}\n"]}

package/lib/stac-api/runtime/README.md

@@ -0,0 +1,36 @@
+# STAC API Lambda runtime notes
+
+This runtime uses a small event-loop helper layer around `Mangum(app, lifespan="off")`.
+
+## Why this exists
+
+We built a separate Lambda sandbox to understand FastAPI + Mangum + `asyncio` behavior in the eoapi-cdk deployment pattern. The goal was to explain why the runtime does explicit async initialization for database pools instead of relying on FastAPI startup hooks alone.
+
+Observed behavior from that sandbox:
+
+- Ordinary FastAPI route execution under Mangum worked without calling `ensure_event_loop()` first.
+- The synchronous Lambda handler did not always have a running loop, but route execution inside Mangum did.
+- `asyncio.run(...)` created long-lived async resources on a temporary loop that was different from the later request-handling loop.
+- Under the sandbox setup, FastAPI startup/lifespan with Mangum `lifespan="auto"` ran per invocation rather than once per warm container.
+- SnapStart restore hooks were synchronous, so async resource recreation still needed a reusable installed loop.
+
+These were sandbox observations, not universal AWS guarantees. We use them as rationale for the runtime pattern below.
+
+## Recommended eoapi-cdk pattern
+
+For Lambda-container-scoped async resources such as database pools, eoapi-cdk prefers:
+
+- explicit async initialization through a reusable installed event loop
+- `Mangum(app, lifespan="off")`
+- `ensure_event_loop()` before delegating to Mangum
+- SnapStart before-snapshot and after-restore hooks when SnapStart is enabled
+
+This means `ensure_event_loop()` is defensive support for synchronous setup paths such as cold-start initialization and SnapStart restore. It is not documented as a requirement for normal FastAPI route execution.
+
+## Practical guidance
+
+- Do not use `asyncio.run(...)` for long-lived async pools or clients created at import time.
+- Do not assume FastAPI startup/lifespan under Mangum is a drop-in replacement for Lambda-container-scoped pool initialization.
+- If SnapStart is enabled, close network resources before snapshot and recreate them after restore.
+
+See [`src/stac_api/handler.py`](src/stac_api/handler.py) and [`../../utils/utils.py`](../../utils/utils.py) for the runtime implementation.

package/lib/stac-api/runtime/pyproject.toml

@@ -5,8 +5,8 @@ description = "stac-api runtime"
 authors = [{ name = "hrodmn", email = "henry@developmentseed.org" }]
 requires-python = ">=3.12"
 dependencies = [
-    "mangum==0.19",
-    "stac-fastapi-pgstac>=6.2,<6.3",
+    "mangum>=0.21.0",
+    "stac-fastapi-pgstac>=6.2,<7.0",
     "starlette-cramjam>=0.4,<0.5",
 ]
 

package/lib/stac-api/runtime/src/stac_api/handler.py

@@ -1,17 +1,17 @@
-"""
-Handler for AWS Lambda.
-"""
+"""Handler for AWS Lambda."""
 
-import asyncio
 import logging
 import os
+from collections.abc import AsyncIterator, Mapping
+from contextlib import asynccontextmanager
+from typing import Any
 
 from mangum import Mangum
 from snapshot_restore_py import register_after_restore, register_before_snapshot
 from stac_fastapi.pgstac.app import app, with_transactions
 from stac_fastapi.pgstac.config import PostgresSettings
 from stac_fastapi.pgstac.db import close_db_connection, connect_to_db
-from utils import get_secret_dict
+from utils import ensure_event_loop, get_secret_dict, run_async
 
 logging.basicConfig(
     level=logging.INFO,
@@ -19,8 +19,8 @@ logging.basicConfig(
 )
 logger = logging.getLogger(__name__)
 
-
 _connection_initialized = False
+_original_lifespan = app.router.lifespan_context
 
 
 def _build_postgres_settings() -> PostgresSettings:
@@ -36,122 +36,118 @@ def _build_postgres_settings() -> PostgresSettings:
     )
 
 
-@register_before_snapshot
-def on_snapshot():
-    """
-    Runtime hook called by Lambda before taking a snapshot.
-    We close database connections that shouldn't be in the snapshot.
-    """
-
-    # Close any existing database connections before the snapshot is taken
+def _close_db_pools() -> None:
+    """Close the current database pools if they exist."""
     if hasattr(app, "state") and hasattr(app.state, "readpool") and app.state.readpool:
         try:
             app.state.readpool.close()
+        except Exception:
+            logger.exception("SnapStart: error closing database readpool")
+        finally:
             app.state.readpool = None
-        except Exception as e:
-            logger.info(f"SnapStart: Error closing database readpool: {e}")
 
     if hasattr(app, "state") and hasattr(app.state, "writepool") and app.state.writepool:
         try:
             app.state.writepool.close()
+        except Exception:
+            logger.exception("SnapStart: error closing database writepool")
+        finally:
             app.state.writepool = None
-        except Exception as e:
-            logger.info(f"SnapStart: Error closing database writepool: {e}")
 
-    return {"statusCode": 200}
 
+async def _initialize_connection() -> None:
+    """Create fresh database connection pools for the application."""
+    global _connection_initialized
 
-@register_after_restore
-def on_snap_restore():
-    """
-    Runtime hook called by Lambda after restoring from a snapshot.
-    We recreate database connections that were closed before the snapshot.
-    """
+    _close_db_pools()
+    await connect_to_db(
+        app,
+        postgres_settings=_build_postgres_settings(),
+        add_write_connection_pool=with_transactions,
+    )
+    _connection_initialized = True
+
+
+async def _shutdown_connection() -> None:
+    """Close the current database connection pools if they exist."""
     global _connection_initialized
 
-    try:
-        # Get the event loop or create a new one
-        try:
-            loop = asyncio.get_running_loop()
-        except RuntimeError:
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
-
-        # Close any existing pool (from snapshot)
-        if hasattr(app.state, "readpool") and app.state.readpool:
-            try:
-                app.state.readpool.close()
-            except Exception as e:
-                logger.info(f"SnapStart: Error closing stale readpool: {e}")
-            app.state.readpool = None
+    if hasattr(app, "state") and hasattr(app.state, "readpool") and app.state.readpool:
+        await close_db_connection(app)
+        app.state.readpool = None
 
-        if hasattr(app.state, "writepool") and app.state.writepool:
-            try:
-                app.state.writepool.close()
-            except Exception as e:
-                logger.info(f"SnapStart: Error closing stale writepool: {e}")
-            app.state.writepool = None
+    if hasattr(app, "state") and hasattr(app.state, "writepool"):
+        app.state.writepool = None
+
+    _connection_initialized = False
 
-        # Create fresh connection pool
-        postgres_settings = _build_postgres_settings()
-        loop.run_until_complete(
-            connect_to_db(
-                app,
-                postgres_settings=postgres_settings,
-                add_write_connection_pool=with_transactions,
-            )
-        )
 
-        _connection_initialized = True
+@register_before_snapshot
+def on_snapshot() -> dict[str, int]:
+    """Close database connections before Lambda SnapStart takes a snapshot."""
+    _close_db_pools()
+    return {"statusCode": 200}
+
 
-    except Exception as e:
-        logger.error(f"SnapStart: Failed to initialize database connection: {e}")
+@register_after_restore
+def on_snap_restore() -> dict[str, int]:
+    """Recreate database connections after Lambda SnapStart restores a snapshot."""
+    try:
+        run_async(_initialize_connection())
+    except Exception:
+        logger.exception("SnapStart: failed to initialize database connection")
         raise
 
     return {"statusCode": 200}
 
 
-@app.on_event("startup")
-async def startup_event():
-    """Connect to database on startup."""
-    logger.info("Setting up DB connection...")
-    postgres_settings = _build_postgres_settings()
-    await connect_to_db(
-        app,
-        postgres_settings=postgres_settings,
-        add_write_connection_pool=with_transactions,
-    )
-    logger.info("DB connection setup.")
+@asynccontextmanager
+async def lifespan(app_instance) -> AsyncIterator[Mapping[str, Any] | None]:
+    """Wrap the upstream lifespan with database setup and teardown.
 
+    We keep the app's lifespan wiring intact for non-Lambda contexts, but the
+    Lambda runtime below uses ``Mangum(..., lifespan="off")`` and performs
+    connection setup explicitly. In sandbox testing, Mangum lifespan handling
+    was not a drop-in replacement for Lambda-container-scoped pool reuse.
+    """
+    async with _original_lifespan(app_instance) as state:
+        await _initialize_connection()
+        try:
+            yield state
+        finally:
+            await _shutdown_connection()
 
-@app.on_event("shutdown")
-async def shutdown_event():
-    """Close database connection."""
-    print("Closing up DB connection...")
-    await close_db_connection(app)
-    print("DB connection closed.")
 
+app.router.lifespan_context = lifespan
 
-handler = Mangum(
+# The Lambda runtime initializes long-lived async resources on an installed
+# reusable loop, then hands request execution to Mangum. ``ensure_event_loop``
+# is a defensive step for those synchronous initialization paths. It is not here
+# because normal FastAPI route execution cannot run without it.
+_asgi_handler = Mangum(
     app,
     lifespan="off",
     text_mime_types=[
-        # Avoid base64 encoding any text/* or application/* mime-types
         "text/",
         "application/",
     ],
 )
 
 
+def handler(event: Any, context: Any) -> dict[str, Any]:
+    """Handle AWS Lambda events with a reusable installed event loop.
+
+    This supports synchronous Lambda-side async setup such as cold-start and
+    SnapStart restore initialization before control passes to Mangum.
+    """
+    ensure_event_loop()
+    return _asgi_handler(event, context)
+
+
 if "AWS_EXECUTION_ENV" in os.environ:
     logger.info("Cold start: initializing database connection...")
-    loop = asyncio.new_event_loop()
-    asyncio.set_event_loop(loop)
-    loop.run_until_complete(
-        connect_to_db(
-            app,
-            postgres_settings=_build_postgres_settings(),
-            add_write_connection_pool=with_transactions,
-        )
-    )
+    # Avoid ``asyncio.run(...)`` here. It would create the pools on a temporary
+    # loop and then close it, which is a poor fit for container-scoped async
+    # resources that should live on the installed reusable loop.
+    run_async(_initialize_connection())
     logger.info("Database connection initialized.")