velocity-python 0.1.21__tar.gz → 0.1.23__tar.gz

{velocity_python-0.1.21/src/velocity_python.egg-info → velocity_python-0.1.23}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.21
+Version: 0.1.23
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.21 → velocity_python-0.1.23}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "velocity-python"
-version = "0.1.21"
+version = "0.1.23"
 authors = [
   { name="Velocity Team", email="info@codeclubs.org" },
 ]

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity/__init__.py

@@ -1,4 +1,4 @@
-__version__ = version = "0.1.21"
+__version__ = version = "0.1.23"
 
 import importlib as _importlib
 

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity/aws/__init__.py

@@ -28,6 +28,16 @@ _LAZY_ATTRS = {
     "initialize_build_environment": "velocity.aws.amplify_build",
     "run_backend_deployment": "velocity.aws.amplify_build",
     "update_lambda_layers_to_latest": "velocity.aws.amplify_build",
+    # S3 utilities
+    "generate_presigned_get": "velocity.aws.s3",
+    "generate_presigned_put": "velocity.aws.s3",
+    "list_client_files": "velocity.aws.s3",
+    "normalize_client_prefix": "velocity.aws.s3",
+    "CLIENT_FILES_BUCKET": "velocity.aws.s3",
+    "PUBLIC_ASSETS_BUCKET": "velocity.aws.s3",
+    "BACKOFFICE_BUCKET": "velocity.aws.s3",
+    "PRIVATE_BUCKETS": "velocity.aws.s3",
+    "ALLOWED_UPLOAD_BUCKETS": "velocity.aws.s3",
 }
 
 
@@ -47,4 +57,14 @@ __all__ = [
     "initialize_build_environment",
     "run_backend_deployment",
     "update_lambda_layers_to_latest",
+    # S3 utilities
+    "generate_presigned_get",
+    "generate_presigned_put",
+    "list_client_files",
+    "normalize_client_prefix",
+    "CLIENT_FILES_BUCKET",
+    "PUBLIC_ASSETS_BUCKET",
+    "BACKOFFICE_BUCKET",
+    "PRIVATE_BUCKETS",
+    "ALLOWED_UPLOAD_BUCKETS",
 ]

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity/aws/amplify_build.py

@@ -235,6 +235,36 @@ def retryable_call(
             raise
 
 
+def resolve_latest_layer_arns(
+    lambda_client,
+    current_layers: Sequence[Mapping[str, Any]],
+) -> Sequence[str]:
+    updated_layer_arns = []
+
+    for layer in current_layers or ():
+        layer_arn = layer["Arn"]
+        layer_name = layer_arn.split(":")[-2]
+        current_version = layer_arn.split(":")[-1]
+
+        latest_response = retryable_call(
+            lambda_client.list_layer_versions,
+            LayerName=layer_name,
+            MaxItems=1,
+        )
+
+        if latest_response and latest_response.get("LayerVersions"):
+            latest_version_info = latest_response["LayerVersions"][0]
+            latest_version = latest_version_info["Version"]
+            latest_arn = latest_version_info["LayerVersionArn"]
+            updated_layer_arns.append(
+                latest_arn if str(latest_version) != str(current_version) else layer_arn
+            )
+        else:
+            updated_layer_arns.append(layer_arn)
+
+    return updated_layer_arns
+
+
 def _serialize_policy_document(policy_document: Any) -> str:
     if isinstance(policy_document, str):
         return policy_document
@@ -443,6 +473,16 @@ def run_backend_deployment(
 
         timeout_value = config.resolve_timeout(function_name)
         memory_value = config.resolve_memory_size(function_name)
+        layers_value = None
+        current_layers = function.get("Layers") or []
+        if current_layers:
+            try:
+                layers_value = list(resolve_latest_layer_arns(lambda_client, current_layers))
+            except Exception as exc:
+                print(
+                    f"[WARN] Unable to resolve latest layers for {function_name}: {exc}. "
+                    "Keeping current layer attachments."
+                )
         print(
             f"[INFO] Updating Lambda function {function_name} with timeout={timeout_value}"
             + (
@@ -456,6 +496,7 @@ def run_backend_deployment(
             memory_size=memory_value,
             subnet_ids=subnet_ids,
             security_group_ids=security_group_ids,
+            layers=layers_value,
         )
 
         if not set_cloudwatch_logging(
@@ -563,44 +604,34 @@ def update_lambda_layers_to_latest(
                 layer_arn = layer["Arn"]
                 layer_name = layer_arn.split(":")[-2]
                 current_version = layer_arn.split(":")[-1]
-
                 print(
                     f"[INFO] Processing layer: {layer_name} (current version: {current_version})"
                 )
 
-                try:
-                    latest_response = retryable_call(
-                        lambda_client.list_layer_versions,
-                        LayerName=layer_name,
-                        MaxItems=1,
+            try:
+                updated_layer_arns = list(
+                    resolve_latest_layer_arns(lambda_client, current_layers)
+                )
+            except Exception as exc:
+                print(f"[ERROR] Failed to resolve latest layers: {exc}")
+                print("[INFO] Keeping current layer versions")
+                updated_layer_arns = [layer["Arn"] for layer in current_layers]
+
+            for original_arn, updated_arn in zip(
+                [layer["Arn"] for layer in current_layers],
+                updated_layer_arns,
+            ):
+                layer_name = original_arn.split(":")[-2]
+                current_version = original_arn.split(":")[-1]
+                latest_version = updated_arn.split(":")[-1]
+                if updated_arn != original_arn:
+                    print(
+                        f"[INFO] Updating {layer_name}: v{current_version} -> v{latest_version}"
                     )
-
-                    if latest_response and latest_response.get("LayerVersions"):
-                        latest_version_info = latest_response["LayerVersions"][0]
-                        latest_version = latest_version_info["Version"]
-                        latest_arn = latest_version_info["LayerVersionArn"]
-
-                        if str(latest_version) != str(current_version):
-                            print(
-                                f"[INFO] Updating {layer_name}: v{current_version} -> v{latest_version}"
-                            )
-                            updated_layer_arns.append(latest_arn)
-                        else:
-                            print(
-                                f"[INFO] {layer_name} is already at latest version (v{latest_version})"
-                            )
-                            updated_layer_arns.append(layer_arn)
-                    else:
-                        print(
-                            f"[WARN] No versions found for layer {layer_name}, keeping current version"
-                        )
-                        updated_layer_arns.append(layer_arn)
-                except Exception as exc:
+                else:
                     print(
-                        f"[ERROR] Failed to get latest version for layer {layer_name}: {exc}"
+                        f"[INFO] {layer_name} is already at latest version (v{latest_version})"
                     )
-                    print(f"[INFO] Keeping current version for {layer_name}")
-                    updated_layer_arns.append(layer_arn)
 
             current_layer_arns = [layer["Arn"] for layer in current_layers]
             if updated_layer_arns != current_layer_arns:

velocity_python-0.1.23/src/velocity/aws/s3.py

@@ -0,0 +1,175 @@
+"""Centralized S3 utilities: presigned URL generation and private-file listing.
+
+Architectural principles enforced here
+---------------------------------------
+* All files in *private* buckets (e.g. ``caringcent.client.files``) MUST be
+  stored without a public ACL.  Access is granted exclusively through
+  time-limited presigned GET URLs generated by this module.
+* Direct browser-to-S3 uploads are supported via presigned PUT URLs so that
+  file bytes never pass through Lambda (avoids the 6 MB API Gateway payload
+  ceiling and reduces Lambda cost).
+* Public-asset buckets (``donate.resources``, ``backoffice.resources``) remain
+  unaffected by this module; they continue to use ``ACL: public-read`` when
+  uploaded via ``helpers.upload(public=True)``.
+
+Bucket constants
+-----------------
+Import and compare against these rather than hard-coding bucket names in
+Lambda handlers so a rename only needs to happen in one place.
+"""
+from __future__ import annotations
+
+import re
+import boto3
+
+# ---------------------------------------------------------------------------
+# Bucket name constants
+# ---------------------------------------------------------------------------
+
+CLIENT_FILES_BUCKET: str = "caringcent.client.files"
+"""Private bucket that stores per-client files (billing reports, uploads)."""
+
+PUBLIC_ASSETS_BUCKET: str = "donate.resources"
+"""Public bucket for images and form-builder assets embedded in donation forms."""
+
+BACKOFFICE_BUCKET: str = "backoffice.resources"
+"""Internal bucket for BackOffice admin assets (help videos, data-load ZIPs)."""
+
+# Buckets that must never be served with a public ACL.
+PRIVATE_BUCKETS: frozenset[str] = frozenset({CLIENT_FILES_BUCKET})
+
+# Buckets that are permitted as upload destinations from BackOffice.
+ALLOWED_UPLOAD_BUCKETS: frozenset[str] = frozenset(
+    {CLIENT_FILES_BUCKET, PUBLIC_ASSETS_BUCKET, BACKOFFICE_BUCKET}
+)
+
+
+# ---------------------------------------------------------------------------
+# Presigned URL helpers
+# ---------------------------------------------------------------------------
+
+def generate_presigned_get(
+    bucket: str,
+    key: str,
+    *,
+    expires_in: int = 3600,
+    filename: str | None = None,
+    content_type: str | None = None,
+) -> str:
+    """Return a presigned GET URL for a private S3 object.
+
+    Args:
+        bucket: S3 bucket name.
+        key: S3 object key.
+        expires_in: URL lifetime in seconds (default 1 hour).
+        filename: When provided the presigned URL includes a
+            ``Content-Disposition: attachment; filename="..."`` override so the
+            browser downloads the file under *filename* instead of navigating
+            to the raw key.  This also prevents the browser from navigating
+            away from the current SPA page.
+        content_type: Optional ``Content-Type`` override embedded in the
+            presigned URL query-string.
+
+    Returns:
+        A time-limited, signed HTTPS URL that grants GET access to the object.
+    """
+    params: dict = {"Bucket": bucket, "Key": key}
+    if filename:
+        params["ResponseContentDisposition"] = f'attachment; filename="{filename}"'
+    if content_type:
+        params["ResponseContentType"] = content_type
+    s3 = boto3.client("s3")
+    return s3.generate_presigned_url("get_object", Params=params, ExpiresIn=expires_in)
+
+
+def generate_presigned_put(
+    bucket: str,
+    key: str,
+    *,
+    content_type: str | None = None,
+    expires_in: int = 900,
+) -> dict:
+    """Return a presigned PUT URL for a direct browser-to-S3 upload.
+
+    Using this URL the browser PUTs the file body directly to S3, bypassing
+    Lambda entirely.  This removes the 6 MB API Gateway payload limit and
+    reduces Lambda invocation cost for large files.
+
+    Args:
+        bucket: S3 bucket name.
+        key: S3 object key for the uploaded file.
+        content_type: Optional MIME type.  When supplied the client **must**
+            send the same ``Content-Type`` header in the PUT request, otherwise
+            S3 rejects the upload with a 403.
+        expires_in: URL lifetime in seconds (default 15 minutes).
+
+    Returns:
+        dict with keys ``url`` (the presigned PUT URL), ``key``, and
+        ``bucket``.  Pass this dict back to the frontend; the browser calls
+        ``fetch(url, { method: 'PUT', body: file })`` to upload.
+    """
+    params: dict = {"Bucket": bucket, "Key": key}
+    if content_type:
+        params["ContentType"] = content_type
+    s3 = boto3.client("s3")
+    url = s3.generate_presigned_url("put_object", Params=params, ExpiresIn=expires_in)
+    return {"url": url, "key": key, "bucket": bucket}
+
+
+# ---------------------------------------------------------------------------
+# Object listing helpers
+# ---------------------------------------------------------------------------
+
+def normalize_client_prefix(client_id: str) -> str:
+    """Normalise *client_id* to the S3 key prefix used when storing files.
+
+    The convention (established by ``OnActionAdminUploadFiles``) is
+    ``lowercase + spaces → hyphens``, matching the existing
+    ``client_id.lower().replace(" ", "-")`` pattern.
+    """
+    return re.sub(r"\s+", "-", (client_id or "").strip().lower())
+
+
+def list_client_files(
+    bucket: str,
+    client_prefix: str,
+    *,
+    expires_in: int = 3600,
+) -> list[dict]:
+    """List non-empty objects under *client_prefix* and attach presigned URLs.
+
+    Zero-byte objects (S3 directory markers created by the console) are
+    silently skipped.
+
+    Each returned dict is the original S3 ``Contents`` entry enriched with:
+
+    * ``SignedUrl`` – presigned GET URL valid for *expires_in* seconds.
+    * ``Header`` – humanized sub-folder name (second-to-last key component),
+      used as the category label in :class:`S3DownloadsList`.
+    * ``FileName`` – the bare filename (last key component).
+
+    Args:
+        bucket: S3 bucket name.
+        client_prefix: Key prefix, typically the normalized client ID.
+        expires_in: Presigned URL lifetime in seconds (default 1 hour).
+
+    Returns:
+        List of enriched object dicts, empty if the prefix has no objects.
+    """
+    s3 = boto3.client("s3")
+    result = s3.list_objects_v2(Bucket=bucket, Prefix=client_prefix, MaxKeys=100)
+    enriched: list[dict] = []
+    for obj in result.get("Contents", []):
+        if obj.get("Size", 0) == 0:
+            continue  # skip directory-marker objects
+        key: str = obj["Key"]
+        parts = key.split("/")
+        obj["SignedUrl"] = generate_presigned_get(bucket, key, expires_in=expires_in)
+        obj["Header"] = (
+            parts[-2].replace("_", " ").replace("-", " ").title()
+            if len(parts) > 1
+            else ""
+        )
+        obj["FileName"] = parts[-1]
+        enriched.append(obj)
+    return enriched

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity/db/core/async_support.py

@@ -493,10 +493,18 @@ class AsyncTransaction:
 
         # R12 — Slow query logging
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
+            from velocity.db.core.transaction import _summarize_sql
+
+            sql_preview = _summarize_sql(sql)
             _logger.warning(
                 "Slow async query: %.1f ms sql=%s",
-                elapsed_ms, sql[:200],
-                extra={"query_duration_ms": round(elapsed_ms, 1)},
+                elapsed_ms,
+                sql_preview,
+                extra={
+                    "query_duration_ms": round(elapsed_ms, 1),
+                    "sql_preview": sql_preview,
+                },
+                stack_info=True,
             )
 
         # R14 — N+1 detection

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity/db/core/transaction.py

@@ -23,6 +23,7 @@ _DEFAULT_QUERY_CACHE_SIZE = int(os.environ.get("VELOCITY_QUERY_CACHE_SIZE", "100
 
 # Slow-query threshold in milliseconds (0 = disabled).
 _SLOW_QUERY_MS = int(os.environ.get("VELOCITY_SLOW_QUERY_MS", "500"))
+_SLOW_QUERY_SQL_CHARS = int(os.environ.get("VELOCITY_SLOW_QUERY_SQL_CHARS", "4000"))
 
 # N+1 detection: warn when the same table is SELECTed more than this many
 # times within a single transaction.  0 = disabled.  Only active when the
@@ -76,6 +77,16 @@ def _extract_table_name(sql):
     return None
 
 
+def _summarize_sql(sql, limit=None):
+    if not sql:
+        return None
+    compact = " ".join(str(sql).split())
+    max_chars = _SLOW_QUERY_SQL_CHARS if limit is None else limit
+    if max_chars and len(compact) > max_chars:
+        return compact[:max_chars] + "... [truncated]"
+    return compact
+
+
 class Transaction:
     """
     Encapsulates a single transaction in the database (connection + commit/rollback).
@@ -210,14 +221,17 @@ class Transaction:
         if _SLOW_QUERY_MS and elapsed_ms > _SLOW_QUERY_MS:
             op = _classify_sql(sql)
             tbl = _extract_table_name(sql)
+            sql_preview = _summarize_sql(sql)
             _logger.warning(
-                "Slow query (%s): %.1f ms table=%s",
-                op, elapsed_ms, tbl,
+                "Slow query (%s): %.1f ms table=%s sql=%s",
+                op, elapsed_ms, tbl, sql_preview,
                 extra={
                     "query_duration_ms": round(elapsed_ms, 1),
                     "table_name": tbl,
                     "operation": op,
+                    "sql_preview": sql_preview,
                 },
+                stack_info=True,
             )
 
         # R14 — N+1 detection (only when debug=True).

{velocity_python-0.1.21 → velocity_python-0.1.23/src/velocity_python.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: velocity-python
-Version: 0.1.21
+Version: 0.1.23
 Summary: A rapid application development library for interfacing with data storage
 Author-email: Velocity Team <info@codeclubs.org>
 License-Expression: MIT

{velocity_python-0.1.21 → velocity_python-0.1.23}/src/velocity_python.egg-info/SOURCES.txt

@@ -6,6 +6,7 @@ src/velocity/logging.py
 src/velocity/aws/__init__.py
 src/velocity/aws/amplify.py
 src/velocity/aws/amplify_build.py
+src/velocity/aws/s3.py
 src/velocity/aws/handlers/__init__.py
 src/velocity/aws/handlers/base_handler.py
 src/velocity/aws/handlers/context.py

velocity_python-0.1.23/tests/test_amplify_build.py

@@ -0,0 +1,150 @@
+from velocity.aws.amplify_build import (
+    BackendDeploymentConfig,
+    build_environment_variables,
+    get_amplify_app_id_and_branch,
+    run_backend_deployment,
+)
+
+
+class FakeAmplifyProject:
+    def get_merged_env_vars(self, branch):
+        return {"EXISTING": branch}
+
+    def get_region(self):
+        return "us-east-1"
+
+
+class FakeDeployProject(FakeAmplifyProject):
+    def __init__(self):
+        self.updated_functions = []
+
+    def list_lambda_functions_filtered(self, branch):
+        return [
+            {
+                "FunctionName": f"ClientEvents-{branch}",
+                "Layers": [
+                    {
+                        "Arn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:225"
+                    },
+                    {
+                        "Arn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34"
+                    },
+                ],
+            }
+        ]
+
+    def update_lambda_function(self, **kwargs):
+        self.updated_functions.append(kwargs)
+
+
+class FakeLambdaClient:
+    def list_layer_versions(self, LayerName, MaxItems):
+        versions = {
+            "py-lib-support": [
+                {
+                    "Version": 240,
+                    "LayerVersionArn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:240",
+                }
+            ],
+            "py-lib-accounting": [
+                {
+                    "Version": 34,
+                    "LayerVersionArn": "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34",
+                }
+            ],
+        }
+        return {"LayerVersions": versions[LayerName][:MaxItems]}
+
+
+def test_backend_deployment_config_resolves_queue_timeout_and_memory_size():
+    config = BackendDeploymentConfig(
+        queue_name_template="clients-queue-{branch}",
+        short_timeout_tokens=("Events", "Data"),
+        memory_size_by_token={"QueueHandler": 1024, "Events": 512},
+    )
+
+    assert config.resolve_queue_name("Demo") == "clients-queue-demo"
+    assert config.resolve_timeout("ClientEvents-demo") == 60
+    assert config.resolve_timeout("ClientUtility-demo") == 900
+    assert config.resolve_memory_size("ClientQueueHandler-demo") == 1024
+    assert config.resolve_memory_size("ClientEvents-demo") == 512
+    assert config.resolve_memory_size("ClientUtility-demo") is None
+
+
+def test_build_environment_variables_reads_project_metadata(tmp_path, monkeypatch):
+    amplify_dir = tmp_path / "amplify" / "backend"
+    amplify_dir.mkdir(parents=True)
+    (amplify_dir / "amplify-meta.json").write_text('{"UserPoolId": "us-east-1_demoPool",}')
+
+    monkeypatch.setenv("AWS_JOB_ID", "job-123")
+    app = FakeAmplifyProject()
+
+    env_vars = build_environment_variables(
+        app,
+        "demo",
+        "clients-queue-demo",
+        project_root=tmp_path,
+    )
+
+    assert env_vars["EXISTING"] == "demo"
+    assert env_vars["SqsWorkQueue"] == "clients-queue-demo"
+    assert env_vars["AWS_JOB_ID"] == "job-123"
+    assert env_vars["AWS_USER_POOL_ID"] == "us-east-1_demoPool"
+    assert env_vars["USER_BRANCH"] == "demo"
+    assert env_vars["REACT_APP_USER_BRANCH"] == "demo"
+    assert env_vars["USER_REGION"] == "us-east-1"
+    assert env_vars["LOGLEVEL"] == "INFO"
+    assert "BUILD_DATETIME" in env_vars
+
+
+def test_get_amplify_app_id_and_branch_uses_team_provider_info(tmp_path, monkeypatch):
+    team_provider_path = tmp_path / "amplify"
+    team_provider_path.mkdir(parents=True)
+    (team_provider_path / "team-provider-info.json").write_text(
+        '{"demo": {"awscloudformation": {"AmplifyAppId": "app-123"}}}'
+    )
+
+    monkeypatch.setenv("AWS_BRANCH", "demo")
+    monkeypatch.delenv("AWS_APP_ID", raising=False)
+
+    app_id, branch = get_amplify_app_id_and_branch(tmp_path)
+
+    assert app_id == "app-123"
+    assert branch == "demo"
+
+
+def test_run_backend_deployment_refreshes_lambda_layers(monkeypatch, tmp_path):
+    monkeypatch.setattr(
+        "velocity.aws.amplify_build.ensure_lambda_policies_and_attach",
+        lambda *args, **kwargs: None,
+    )
+    monkeypatch.setattr(
+        "velocity.aws.amplify_build.set_cloudwatch_logging",
+        lambda *args, **kwargs: True,
+    )
+
+    app = FakeDeployProject()
+    config = BackendDeploymentConfig(
+        queue_name_template="clients-queue-{branch}",
+        short_timeout_tokens=("Events",),
+        memory_size_by_token={"Events": 512},
+    )
+
+    run_backend_deployment(
+        "app-123",
+        "demo",
+        config,
+        project_root=tmp_path,
+        app=app,
+        lambda_client=FakeLambdaClient(),
+        logs_client=object(),
+    )
+
+    assert len(app.updated_functions) == 1
+    assert app.updated_functions[0]["function_name"] == "ClientEvents-demo"
+    assert app.updated_functions[0]["timeout"] == 60
+    assert app.updated_functions[0]["memory_size"] == 512
+    assert app.updated_functions[0]["layers"] == [
+        "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-support:240",
+        "arn:aws:lambda:us-east-1:741671896925:layer:py-lib-accounting:34",
+    ]

{velocity_python-0.1.21 → velocity_python-0.1.23}/tests/test_async_support.py

@@ -687,3 +687,8 @@ class TestAsyncSlowQueryLogging:
                     if "Slow" in str(c)
                 ]
                 assert len(slow_calls) >= 1
+                args = slow_calls[0].args
+                kwargs = slow_calls[0].kwargs
+                assert args[2] == "SELECT * FROM large_table"
+                assert kwargs["extra"]["sql_preview"] == "SELECT * FROM large_table"
+                assert kwargs["stack_info"] is True

{velocity_python-0.1.21 → velocity_python-0.1.23}/tests/test_observability.py

@@ -177,6 +177,7 @@ class TestSlowQueryLogging:
 
         assert any("Slow query" in r.message for r in caplog.records)
         assert any("big_table" in r.message for r in caplog.records)
+        assert any("sql=SELECT * FROM big_table" in r.message for r in caplog.records)
 
     def test_fast_query_no_warning(self, caplog):
         tx = _make_tx()
@@ -230,6 +231,8 @@ class TestSlowQueryLogging:
         assert rec.query_duration_ms > 0
         assert rec.table_name == "orders"
         assert rec.operation == "SELECT"
+        assert rec.sql_preview == "SELECT * FROM orders WHERE id = 1"
+        assert rec.stack_info
 
 
 # ──────────────────────────────────────────────────────────────────────