@aws/nx-plugin 1.0.0-rc.7 → 1.0.0-rc.71

package/src/py/rdb/files/__name__/migration_handler.py.template

@@ -0,0 +1,36 @@
+import asyncio
+import ssl
+
+from alembic import command
+from alembic.config import Config
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlalchemy.pool import NullPool
+
+from .utils import build_database_url, get_database_secret, with_connection_retry
+
+
+def _apply_migrations(sync_conn, alembic_cfg: Config) -> None:
+    alembic_cfg.attributes['connection'] = sync_conn
+    command.upgrade(alembic_cfg, 'head')
+
+
+async def _run_migrations() -> None:
+    secret = get_database_secret()
+    database_url = build_database_url(
+        secret['username'], secret['host'], secret['port'], secret['dbname'],
+        password=secret['password'],
+    )
+    alembic_cfg = Config('alembic.ini')
+    engine = create_async_engine(
+        database_url, poolclass=NullPool,
+        connect_args={'ssl': ssl.create_default_context()},
+    )
+    try:
+        async with engine.begin() as conn:
+            await conn.run_sync(lambda c: _apply_migrations(c, alembic_cfg))
+    finally:
+        await engine.dispose()
+
+
+def handler(_event, _context):
+    with_connection_retry(lambda: asyncio.run(_run_migrations()))

package/src/py/rdb/files/__name__/models/__init__.py.template

@@ -0,0 +1,3 @@
+from .example import ExampleModel
+
+__all__ = ['ExampleModel']

package/src/py/rdb/files/__name__/models/example.py.template

@@ -0,0 +1,8 @@
+from sqlalchemy import Column, String
+from sqlmodel import Field, SQLModel
+
+
+class ExampleModel(SQLModel, table=True):
+    id: int | None = Field(default=None, primary_key=True)
+    name: str = Field(sa_column=Column(String(255), nullable=False))
+    description: str | None = Field(default=None, sa_column=Column(String(255), nullable=True))

package/src/py/rdb/files/__name__/utils.py.template

@@ -0,0 +1,104 @@
+import json
+import os
+import time
+from collections.abc import Callable
+from typing import Any
+
+import boto3
+from aws_lambda_powertools.utilities.parameters import AppConfigProvider
+from sqlalchemy import URL
+
+DatabaseConfig = dict[str, Any]
+DatabaseSecret = dict[str, Any]
+
+def build_database_url(
+    username: str,
+    host: str,
+    port: int,
+    database: str,
+    password: str | None = None,
+) -> URL:
+    return URL.create(
+        drivername='<%= engine === "mysql" ? "mysql+aiomysql" : "postgresql+asyncpg" %>',
+        username=username,
+        password=password,
+        host=host,
+        port=port,
+        database=database,
+    )
+
+
+def is_local_dev() -> bool:
+    return os.environ.get('LOCAL_DEV') == 'true'
+
+
+def get_local_dev_config() -> dict:
+    config_path = os.path.join(os.path.dirname(__file__), '..', 'config.json')
+    with open(config_path) as f:
+        return json.load(f)['localDev']
+
+
+def get_database_secret() -> DatabaseSecret:
+    secret_arn = os.environ.get('DATABASE_SECRET_ARN')
+    if not secret_arn:
+        raise ValueError('Missing required environment variable DATABASE_SECRET_ARN.')
+    client = boto3.client('secretsmanager')
+    response = client.get_secret_value(SecretId=secret_arn)
+    return json.loads(response['SecretString'])
+
+
+_database_config: dict[str, DatabaseConfig] = {}
+
+
+def get_database_config(runtime_config_key: str) -> DatabaseConfig:
+    if runtime_config_key not in _database_config:
+        app_id = os.environ.get('RUNTIME_CONFIG_APP_ID')
+        if not app_id:
+            raise ValueError('Missing required environment variable RUNTIME_CONFIG_APP_ID.')
+        provider = AppConfigProvider(application=app_id, environment='default')
+        config = provider.get('database', transform='json')
+        if not isinstance(config, dict):
+            raise ValueError('Unexpected RuntimeConfig format: expected JSON object.')
+        db_config = config.get(runtime_config_key)
+        if not db_config:
+            raise ValueError(f'RuntimeConfig is missing database.{runtime_config_key}.')
+        _database_config[runtime_config_key] = db_config
+    return _database_config[runtime_config_key]
+
+
+_TRANSIENT_ERROR_PATTERNS = [
+    'timeout',
+    'connection refused',
+    'could not connect',
+    'connection reset',
+    'connection timed out',
+    'operationalerror',
+    'password authentication failed',
+    'access denied',
+    'temporary failure',
+]
+
+
+def is_transient_connection_error(error: Exception) -> bool:
+    error_str = str(error).lower()
+    return any(p in error_str for p in _TRANSIENT_ERROR_PATTERNS)
+
+
+def with_connection_retry[T](
+    fn: Callable[[], T],
+    max_attempts: int = 6,
+    delay_seconds: float = 10.0,
+) -> T:
+    for attempt in range(1, max_attempts + 1):
+        try:
+            return fn()
+        except Exception as e:
+            if attempt == max_attempts or not is_transient_connection_error(e):
+                raise
+            wait = delay_seconds * attempt
+            print(
+                f'Transient connection error (attempt {attempt}/{max_attempts}), '
+                f'retrying in {wait:.0f}s: {e}'
+            )
+            time.sleep(wait)
+    raise RuntimeError('unreachable')

package/src/py/rdb/files/alembic.ini.template

@@ -0,0 +1,38 @@
+[alembic]
+script_location = migrations
+file_template = %%(year)d%%(month).2d%%(day).2d_%%(hour).2d%%(minute).2d_%%(rev)s_%%(slug)s
+prepend_sys_path = .
+
+[loggers]
+keys = root,sqlalchemy,alembic
+
+[handlers]
+keys = console
+
+[formatters]
+keys = generic
+
+[logger_root]
+level = WARN
+handlers = console
+qualname =
+
+[logger_sqlalchemy]
+level = WARN
+handlers =
+qualname = sqlalchemy.engine
+
+[logger_alembic]
+level = INFO
+handlers =
+qualname = alembic
+
+[handler_console]
+class = StreamHandler
+args = (sys.stderr,)
+level = NOTSET
+formatter = generic
+
+[formatter_generic]
+format = %(levelname)-5.5s [%(name)s] %(message)s
+datefmt = %H:%M:%S

package/src/py/rdb/files/config.json.template

@@ -0,0 +1,14 @@
+{
+  "runtimeConfigKey": "<%= runtimeConfigKey %>",
+  "localDev": {
+    "containerEngine": "<%= containerEngine %>",
+    "containerName": "<%= containerName %>",
+    "image": "<%= dockerImage %>",
+    "port": <%= localDbPort %>,
+    "host": "<%= localDbHost %>",
+    "dbName": "<%= localDbName %>",
+    "dbUser": "<%= localDbUser %>",
+    "dbPassword": "<%= localDbPassword %>",
+    "dbEngine": "<%= engine %>"
+  }
+}

package/src/py/rdb/files/migrations/env.py.template

@@ -0,0 +1,80 @@
+import asyncio
+import json
+import os
+from logging.config import fileConfig
+
+from alembic import context
+from sqlalchemy import URL
+from sqlalchemy.ext.asyncio import create_async_engine
+from sqlmodel import SQLModel
+
+# Import all models to register them in SQLModel.metadata
+from <%= name %>.models import *  # noqa: F403
+
+config = context.config
+
+if config.config_file_name is not None:
+    fileConfig(config.config_file_name)
+
+target_metadata = SQLModel.metadata
+
+
+def _get_local_url():
+    if os.environ.get('LOCAL_DEV') == 'true':
+        config_path = os.path.join(os.path.dirname(__file__), '..', 'config.json')
+        with open(config_path) as f:
+            cfg = json.load(f)['localDev']
+        engine = cfg['dbEngine']
+        driver = 'mysql+aiomysql' if engine == 'mysql' else 'postgresql+asyncpg'
+        return URL.create(
+            driver,
+            username=cfg['dbUser'],
+            password=cfg['dbPassword'],
+            host=cfg['host'],
+            port=cfg['port'],
+            database=cfg['dbName'],
+        )
+
+    raise RuntimeError('Run alembic via nx run <project>:alembic')
+
+
+# Generates SQL script without a live DB connection (alembic upgrade head --sql)
+def run_migrations_offline() -> None:
+    context.configure(
+        url=_get_local_url(),
+        target_metadata=target_metadata,
+        literal_binds=True,
+        dialect_opts={'paramstyle': 'named'},
+    )
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+def _run_migrations_sync(sync_conn) -> None:
+    context.configure(connection=sync_conn, target_metadata=target_metadata)
+    with context.begin_transaction():
+        context.run_migrations()
+
+
+# Runs migrations against a live DB connection
+def run_migrations_online() -> None:
+    supplied_connection = config.attributes.get('connection')
+    # Connection injected by migration_handler.py (Lambda)
+    if supplied_connection is not None:
+        _run_migrations_sync(supplied_connection)
+        return
+
+    # Local alembic commands run via nx run <project>:alembic
+    async def _run_async() -> None:
+        engine = create_async_engine(_get_local_url())
+        async with engine.begin() as conn:
+            await conn.run_sync(_run_migrations_sync)
+        await engine.dispose()
+
+    asyncio.run(_run_async())
+
+
+if context.is_offline_mode():
+    run_migrations_offline()
+else:
+    run_migrations_online()

package/src/py/rdb/files/migrations/script.py.mako.template

@@ -0,0 +1,28 @@
+"""${message}
+
+Revision ID: ${up_revision}
+Revises: ${down_revision | comma,n}
+Create Date: ${create_date}
+
+"""
+from typing import Sequence, Union
+
+from alembic import op
+import sqlalchemy as sa
+${imports if imports else ""}
+
+# revision identifiers, used by Alembic.
+revision: str = ${repr(up_revision)}
+down_revision: Union[str, Sequence[str], None] = ${repr(down_revision)}
+branch_labels: Union[str, Sequence[str], None] = ${repr(branch_labels)}
+depends_on: Union[str, Sequence[str], None] = ${repr(depends_on)}
+
+
+def upgrade() -> None:
+    """Upgrade schema."""
+    ${upgrades if upgrades else "pass"}
+
+
+def downgrade() -> None:
+    """Downgrade schema."""
+    ${downgrades if downgrades else "pass"}

package/src/py/rdb/generator.d.ts

@@ -0,0 +1,103 @@
+import { type GeneratorCallback, type Tree } from '@nx/devkit';
+import { type NxGeneratorInfo } from '../../utils/nx';
+import { type IacMetadata } from '../../utils/shared-constructs-constants';
+import type { PyRdbGeneratorSchema } from './schema';
+/** The metadata this generator records, which its predicates read. */
+export interface PyRdbMetadata extends IacMetadata {
+    readonly engine: PyRdbGeneratorSchema['engine'];
+}
+export declare const DEPENDENCIES: import("../../utils/declared-dependencies").DependencyDeclaration<readonly [{
+    readonly name: "mariadb";
+    readonly when: (m: PyRdbMetadata) => boolean;
+    readonly root: true;
+}, {
+    readonly name: "pg";
+    readonly when: (m: PyRdbMetadata) => boolean;
+    readonly root: true;
+}, {
+    readonly name: "@types/pg";
+    readonly when: (m: PyRdbMetadata) => boolean;
+    readonly dev: true;
+    readonly root: true;
+}, {
+    readonly name: "ncp";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "rimraf";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "make-dir-cli";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "cpy-cli";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "ncp";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "rimraf";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "make-dir-cli";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "cpy-cli";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "constructs";
+    readonly when: (m: IacMetadata) => boolean;
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "aws-cdk-lib";
+    readonly when: (m: IacMetadata) => boolean;
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "@types/node";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "pg";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "@types/pg";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "mariadb";
+} & {
+    versionOnly: true;
+}, {
+    readonly name: "tsx";
+} & {
+    versionOnly: true;
+}], readonly [{
+    readonly name: "sqlmodel";
+}, {
+    readonly name: "alembic";
+}, {
+    readonly name: "greenlet";
+}, {
+    readonly name: "aiomysql";
+    readonly when: (m: PyRdbMetadata) => boolean;
+}, {
+    readonly name: "asyncpg";
+    readonly when: (m: PyRdbMetadata) => boolean;
+}, {
+    readonly name: "boto3";
+}, {
+    readonly name: "aws-lambda-powertools";
+}]>;
+export declare const PY_RDB_GENERATOR_INFO: NxGeneratorInfo;
+export declare const pyRdbGenerator: (tree: Tree, options: PyRdbGeneratorSchema) => Promise<GeneratorCallback>;
+export default pyRdbGenerator;