bmsdna-devtools 0.32.0__tar.gz → 0.34.0__tar.gz

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.5
 Name: bmsdna-devtools
-Version: 0.32.0
+Version: 0.34.0
 Summary: Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects
 Requires-Python: >=3.14
 Requires-Dist: pgdevkit[db]>=0.7.1
@@ -630,7 +630,8 @@ bdt lint backend/db/a.py b.py  # scan only these files -- e.g. from a prek/pre-c
 bdt lint --no-tooling-check    # skip the tooling-config check for this run
 ```
 
-Every `.execute()`/`.executemany()` call whose SQL argument can be resolved to a
+Every `.execute()`/`.executemany()` call -- and pgdevkit's `fetch_all`/`fetch_one`/`fetch_scalar` and
+`PostgresJsonResponse`, which only accept a literal string, sqlglot expression, `psycopg.sql` or t-string -- whose SQL argument can be resolved to a
 literal or f-string/concatenation/`%`-format expression is checked (an
 unresolvable argument, e.g. a plain function parameter, is silently skipped --
 this can't false-positive on non-psycopg `.execute()` calls, or on dynamic SQL
@@ -647,6 +648,10 @@ it can't see through):
   with an f-string, `+` concatenation, the `%` operator, or `str.format()`
   instead of a psycopg t-string (3.14+), `psycopg.sql`, or bound params. For an f-string the fix is
   usually just `f"..."` -> `t"..."` (`{value}` is bound, `{name:i}` quotes an identifier).
+- **`sql-sqlglot-string-injection`** — an f-string / concatenation / `%` / `.format()` string passed to a
+  sqlglot builder that parses it as SQL (`select(...)`, `.from_()`, `.where()`, `.order_by()`, `parse_one()`, ...).
+  The result is a sqlglot expression, which the rules above otherwise trust, so this is the hole they'd miss.
+  Use `exp.column()`/`exp.to_identifier()` for names and `exp.Placeholder` + bound params for values.
 - **`sql-positional-param`** — positional `%s` instead of named `%(name)s`.
 - **`sql-forbidden-join`** — `RIGHT JOIN`/`LATERAL JOIN`/`CROSS APPLY` (same
   patterns the `prek` skill's `check_files.py` forbids in `.sql` files).
@@ -830,7 +835,7 @@ Findings have two severities: **error** (a definite unsafe pattern, exit code 1)
 (depends on where a value comes from; listed with an instruction for an AI/human to verify, exit
 code 0 unless `--strict`).
 
-- **SQL** (Python `.execute()`): f-string / `%` / concatenation / `.format()` SQL is an error.
+- **SQL** (Python `.execute()` / `fetch_all()` / `fetch_one()` / `fetch_scalar()` / `PostgresJsonResponse()`): f-string / `%` / concatenation / `.format()` SQL is an error.
   SQL from `load_sql()`, `sql.SQL`, sqlglot (`expr.sql()`, `sqlglot.*`), `cast(LiteralString, <sqlglot expr>)` (the cast is only as safe as its argument) or
   a function in the same file annotated `-> LiteralString` is trusted; SQL from any other function
   call is a `sql-unverified-call` review item. (`bdt lint` accepts the same trusted forms but never

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/README.md

@@ -616,7 +616,8 @@ bdt lint backend/db/a.py b.py  # scan only these files -- e.g. from a prek/pre-c
 bdt lint --no-tooling-check    # skip the tooling-config check for this run
 ```
 
-Every `.execute()`/`.executemany()` call whose SQL argument can be resolved to a
+Every `.execute()`/`.executemany()` call -- and pgdevkit's `fetch_all`/`fetch_one`/`fetch_scalar` and
+`PostgresJsonResponse`, which only accept a literal string, sqlglot expression, `psycopg.sql` or t-string -- whose SQL argument can be resolved to a
 literal or f-string/concatenation/`%`-format expression is checked (an
 unresolvable argument, e.g. a plain function parameter, is silently skipped --
 this can't false-positive on non-psycopg `.execute()` calls, or on dynamic SQL
@@ -633,6 +634,10 @@ it can't see through):
   with an f-string, `+` concatenation, the `%` operator, or `str.format()`
   instead of a psycopg t-string (3.14+), `psycopg.sql`, or bound params. For an f-string the fix is
   usually just `f"..."` -> `t"..."` (`{value}` is bound, `{name:i}` quotes an identifier).
+- **`sql-sqlglot-string-injection`** — an f-string / concatenation / `%` / `.format()` string passed to a
+  sqlglot builder that parses it as SQL (`select(...)`, `.from_()`, `.where()`, `.order_by()`, `parse_one()`, ...).
+  The result is a sqlglot expression, which the rules above otherwise trust, so this is the hole they'd miss.
+  Use `exp.column()`/`exp.to_identifier()` for names and `exp.Placeholder` + bound params for values.
 - **`sql-positional-param`** — positional `%s` instead of named `%(name)s`.
 - **`sql-forbidden-join`** — `RIGHT JOIN`/`LATERAL JOIN`/`CROSS APPLY` (same
   patterns the `prek` skill's `check_files.py` forbids in `.sql` files).
@@ -816,7 +821,7 @@ Findings have two severities: **error** (a definite unsafe pattern, exit code 1)
 (depends on where a value comes from; listed with an instruction for an AI/human to verify, exit
 code 0 unless `--strict`).
 
-- **SQL** (Python `.execute()`): f-string / `%` / concatenation / `.format()` SQL is an error.
+- **SQL** (Python `.execute()` / `fetch_all()` / `fetch_one()` / `fetch_scalar()` / `PostgresJsonResponse()`): f-string / `%` / concatenation / `.format()` SQL is an error.
   SQL from `load_sql()`, `sql.SQL`, sqlglot (`expr.sql()`, `sqlglot.*`), `cast(LiteralString, <sqlglot expr>)` (the cast is only as safe as its argument) or
   a function in the same file annotated `-> LiteralString` is trusted; SQL from any other function
   call is a `sql-unverified-call` review item. (`bdt lint` accepts the same trusted forms but never

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/bmsdna/devtools/cli.py

@@ -1092,7 +1092,8 @@ def lint(
         "[tool.bdt.lint] skip_tooling_check = true in pyproject.toml.",
     ),
 ) -> None:
-    """Static checks (bmsuisse/skills#52): postgres/psycopg SQL rules on every `.execute()` call
+    """Static checks (bmsuisse/skills#52): postgres/psycopg SQL rules on every `.execute()` call and pgdevkit
+    `fetch_all`/`fetch_one`/`fetch_scalar`/`PostgresJsonResponse` call
     (must use load_sql()/a .sql file, a t-string, or psycopg.sql for anything beyond a trivial
     query; never an f-string/concatenation/`%`-formatting), pydantic-model placement under api/
     directories, hand-wired HTTP in TypeScript, and that the repo declares/configures ty, ruff, pytest and prek.

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/bmsdna/devtools/find_injection.py

@@ -39,6 +39,7 @@ SQL_INJECTION_RULES = frozenset(
         "sql-percent-format-injection",
         "sql-concat-injection",
         "sql-format-injection",
+        "sql-sqlglot-string-injection",
     }
 )
 _IGNORE_RE = re.compile(r"bdt-lint:\s*ignore\s+([\w-]+(?:\s*,\s*[\w-]+)*)")

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/bmsdna/devtools/lint_sql.py

@@ -1,5 +1,6 @@
 """AST rule engine for `bdt lint`'s postgres/psycopg checks (bmsuisse/skills#52):
-every `.execute()`/`.executemany()` call is classified by how its SQL argument was
+every `.execute()`/`.executemany()` call (and pgdevkit's `fetch_all`/`fetch_one`/`fetch_scalar` and
+`PostgresJsonResponse`) is classified by how its SQL argument was
 built, then checked against the `postgres-best-practices` skill's rules
 (../../skills/postgres-best-practices in a checkout of bmsuisse/skills).
 
@@ -25,7 +26,8 @@ from __future__ import annotations
 import ast
 import re
 import sys
-from dataclasses import dataclass
+from collections.abc import Mapping
+from dataclasses import dataclass, field
 from pathlib import Path
 
 from .lint_findings import Finding
@@ -124,6 +126,7 @@ class _Trust:
 
     sqlglot_names: frozenset[str] = frozenset()
     literal_funcs: frozenset[str] = frozenset()
+    sqlglot_aliases: Mapping[str, str] = field(default_factory=dict)  # local name -> name it was imported as
 
 
 _NO_TRUST = _Trust()
@@ -185,6 +188,7 @@ def _unwrap_str_call(node: ast.Call) -> ast.expr | None:
 def _file_trust(tree: ast.AST) -> _Trust:
     literal_funcs: set[str] = set()
     sqlglot_names: set[str] = set()
+    sqlglot_aliases: dict[str, str] = {}
     for node in ast.walk(tree):
         if isinstance(node, (ast.FunctionDef, ast.AsyncFunctionDef)) and node.returns is not None and _is_literal_string_ref(node.returns):
             literal_funcs.add(node.name)
@@ -192,7 +196,8 @@ def _file_trust(tree: ast.AST) -> _Trust:
             sqlglot_names.update((a.asname or a.name).split(".")[0] for a in node.names if a.name.split(".")[0] == "sqlglot")
         elif isinstance(node, ast.ImportFrom) and (node.module or "").split(".")[0] == "sqlglot":
             sqlglot_names.update(a.asname or a.name for a in node.names)
-    return _Trust(frozenset(sqlglot_names), frozenset(literal_funcs))
+            sqlglot_aliases.update({a.asname or a.name: a.name for a in node.names})
+    return _Trust(frozenset(sqlglot_names), frozenset(literal_funcs), sqlglot_aliases)
 
 
 def _resolve_single(expr: ast.expr, lookup) -> ast.expr:
@@ -450,14 +455,119 @@ def _is_sql_named(name: str) -> bool:
     return lowered == "sql" or lowered.endswith("_sql")
 
 
+# pgdevkit's `fetch_all`/`fetch_one`/`fetch_scalar` and `pgdevkit.fastapi.PostgresJsonResponse` run their first
+# argument as SQL, exactly like `.execute()`, so they get the same rules (plain functions / a class, so matched by
+# bare name too). Matched by name only, so not covered: an alias (`as PJR`), a subclass under another name (the
+# documented `class AppJson(PostgresJsonResponse): expose_errors = ...`), and the pre-pgdevkit
+# `PostgresJsonResponse("postgres", sql, ...)` copy in CCMT2, whose first argument is a connection source -- its SQL
+# only gets checked once that call site moves to pgdevkit.
+_PGDEVKIT_SQL_CALLEES = frozenset({"fetch_all", "fetch_one", "fetch_scalar", "PostgresJsonResponse"})
+
+
 def _execute_query_arg(call: ast.Call) -> ast.expr | None:
-    if not (isinstance(call.func, ast.Attribute) and call.func.attr in ("execute", "executemany")):
+    func = call.func
+    is_execute = isinstance(func, ast.Attribute) and func.attr in ("execute", "executemany")
+    is_fetch_helper = (isinstance(func, ast.Name) and func.id in _PGDEVKIT_SQL_CALLEES) or (
+        isinstance(func, ast.Attribute) and func.attr in _PGDEVKIT_SQL_CALLEES
+    )
+    if not (is_execute or is_fetch_helper):
         return None
     if call.args:
         return call.args[0]
     return next((kw.value for kw in call.keywords if kw.arg == "query"), None)
 
 
+# sqlglot's builders parse plain strings as SQL (`select(f"a, {x}")`, `.where(f"id = {x}")`), so text
+# interpolated into one is as dangerous as text passed straight to `.execute()` -- even though the
+# result is a sqlglot expression the rules above otherwise trust. Value arguments (`exp.column`,
+# `exp.Placeholder`, `exp.convert`, `exp.to_identifier`, ...) quote/bind safely and aren't listed.
+_SQLGLOT_STRING_BUILDERS = frozenset(
+    {"select", "from_", "where", "join", "order_by", "group_by", "having", "with_", "parse_one", "parse", "condition", "and_", "or_", "maybe_parse"}
+)
+# Keyword arguments of those builders that are options, not SQL text.
+_SQLGLOT_NON_SQL_KEYWORDS = frozenset(
+    {"dialect", "read", "write", "copy", "append", "alias", "join_alias", "join_type", "into", "opts", "dialect_name", "table"}
+)
+
+
+def _concat_leaves(node: ast.expr) -> list[ast.expr]:
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        return [*_concat_leaves(node.left), *_concat_leaves(node.right)]
+    return [node]
+
+
+def _is_str_constant(node: ast.expr) -> bool:
+    return isinstance(node, ast.Constant) and isinstance(node.value, str)
+
+
+def _interpolation_kind(node: ast.expr) -> str | None:
+    """How `node` interpolates non-literal text into a string, or None if it doesn't. An
+    interpolated *constant* (`f"{1}"`, `f"{'x'}"`) can't carry user text, so it doesn't count."""
+    if isinstance(node, ast.JoinedStr):
+        dynamic = any(isinstance(v, ast.FormattedValue) and not isinstance(v.value, ast.Constant) for v in node.values)
+        return "an f-string" if dynamic else None
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Add):
+        leaves = _concat_leaves(node)
+        if any(_is_str_constant(x) for x in leaves) and not all(isinstance(x, ast.Constant) for x in leaves):
+            return "string concatenation"
+        return None
+    if isinstance(node, ast.BinOp) and isinstance(node.op, ast.Mod):
+        return "the `%` string-formatting operator" if _is_str_constant(node.left) else None
+    if isinstance(node, ast.Call) and isinstance(node.func, ast.Attribute):
+        if node.func.attr == "format" and _is_str_constant(node.func.value):
+            return "`str.format()`"
+        if node.func.attr == "join" and _is_str_constant(node.func.value) and node.args:
+            # `" and ".join(f"{c} = 1" for c in cols)`: the element is what carries the text
+            elements = _elements(node.args[0])
+            return next((k for e in elements if (k := _interpolation_kind(e)) is not None), None)
+    return None
+
+
+def _elements(node: ast.expr) -> list[ast.expr]:
+    """The element expression(s) of a literal list/tuple or a comprehension/generator."""
+    if isinstance(node, (ast.ListComp, ast.GeneratorExp, ast.SetComp)):
+        return [node.elt]
+    if isinstance(node, (ast.List, ast.Tuple, ast.Set)):
+        return list(node.elts)
+    return []
+
+
+def _sqlglot_builder_findings(
+    call: ast.Call, path: Path, trust: _Trust, lookup, sqlglot_vars: set[str]
+) -> list[Finding]:
+    if not trust.sqlglot_names:
+        return []
+    func = call.func
+    name = func.attr if isinstance(func, ast.Attribute) else func.id if isinstance(func, ast.Name) else None
+    root = _call_root_name(func)
+    if isinstance(func, ast.Name):
+        name = trust.sqlglot_aliases.get(func.id, func.id)  # `from sqlglot import select as s`
+    # Only chains rooted at a sqlglot name or at a variable holding a sqlglot expression: `.where()`/
+    # `.group_by()` on a polars/Django/SQLAlchemy object in the same file is none of our business.
+    if name not in _SQLGLOT_STRING_BUILDERS or not (root in trust.sqlglot_names or root in sqlglot_vars):
+        return []
+    arguments: list[ast.expr] = []
+    for arg in call.args:
+        arguments.append(arg.value if isinstance(arg, ast.Starred) else arg)
+    arguments.extend(kw.value for kw in call.keywords if kw.arg not in _SQLGLOT_NON_SQL_KEYWORDS)
+    for arg in arguments:
+        candidates = [c for top in [arg, *_elements(arg)] for c in _resolve_candidates(top, lookup)]
+        for candidate in candidates:
+            kind = _interpolation_kind(candidate)
+            if kind is not None:
+                return [
+                    Finding(
+                        path,
+                        arg.lineno,
+                        "sql-sqlglot-string-injection",
+                        f"`{name}(...)` parses its string argument as SQL, and it is built with {kind} -- injection risk. "
+                        "Build it from sqlglot nodes instead (`exp.column()`/`exp.to_identifier()` for names, `exp.Placeholder` "
+                        "+ bound params for values).",
+                    )
+                ]
+    return []
+
+
 class _ExecuteCallVisitor(ast.NodeVisitor):
     """Walks a module, tracking a stack of (function/class/module) local-variable scopes so a
     `cur.execute(query, ...)` call can resolve `query` back to every assignment it had in that
@@ -471,6 +581,7 @@ class _ExecuteCallVisitor(ast.NodeVisitor):
         self.review = review
         self.findings: list[Finding] = []
         self._scopes: list[dict[str, list[ast.expr]]] = [{}]
+        self._sqlglot_vars: set[str] = set()  # names bound from a sqlglot expression chain
 
     def _lookup(self, name: str) -> list[ast.expr]:
         for scope in reversed(self._scopes):
@@ -487,14 +598,21 @@ class _ExecuteCallVisitor(ast.NodeVisitor):
     visit_AsyncFunctionDef = _visit_scoped
     visit_ClassDef = _visit_scoped
 
+    def _track_sqlglot_var(self, name: str, value: ast.expr) -> None:
+        if isinstance(value, ast.Call) and (root := _call_root_name(value.func)) is not None:
+            if root in self.trust.sqlglot_names or root in self._sqlglot_vars:
+                self._sqlglot_vars.add(name)
+
     def visit_Assign(self, node: ast.Assign) -> None:
         if len(node.targets) == 1 and isinstance(node.targets[0], ast.Name):
+            self._track_sqlglot_var(node.targets[0].id, node.value)
             self._scopes[-1].setdefault(node.targets[0].id, []).append(node.value)
             self._check_sql_named_literal(node.targets[0].id, node.value, node.lineno)
         self.generic_visit(node)
 
     def visit_AnnAssign(self, node: ast.AnnAssign) -> None:
         if isinstance(node.target, ast.Name) and node.value is not None:
+            self._track_sqlglot_var(node.target.id, node.value)
             self._scopes[-1].setdefault(node.target.id, []).append(node.value)
             self._check_sql_named_literal(node.target.id, node.value, node.lineno)
         self.generic_visit(node)
@@ -515,6 +633,7 @@ class _ExecuteCallVisitor(ast.NodeVisitor):
         return bool(values) and all(isinstance(v, ast.Constant) and isinstance(v.value, str) for v in values)
 
     def visit_Call(self, node: ast.Call) -> None:
+        self.findings.extend(_sqlglot_builder_findings(node, self.path, self.trust, self._lookup, self._sqlglot_vars))
         query_arg = _execute_query_arg(node)
         if query_arg is not None:
             found = _check_query_arg(query_arg, self._lookup, self.path, node.lineno, self.trust, self.review)

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/pyproject.toml

@@ -10,7 +10,7 @@ packages = ["bmsdna"]
 
 [project]
 name = "bmsdna-devtools"
-version = "0.32.0"
+version = "0.34.0"
 description = "Shared Azure DevOps / GitHub / git / Azure Monitor developer tooling for BMS projects"
 readme = "README.md"
 requires-python = ">=3.14"  # pgdevkit>=0.7.1 requires 3.14; was >=3.11 before adding it as a dependency

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/skills/bmsdna-devtools/SKILL.md

@@ -123,7 +123,7 @@ vendor a git submodule under that path.
 
 ## Static checks
 
-- `bdt lint [paths]` -- SQL/psycopg rules, pydantic-model placement, hand-wired HTTP in TypeScript, baseline tooling.
+- `bdt lint [paths]` -- SQL/psycopg rules (`.execute()`, pgdevkit `fetch_*`, `PostgresJsonResponse`), pydantic-model placement, hand-wired HTTP in TypeScript, baseline tooling.
 - `uv run bdt dead-code` -- dead code a linter can't see, configured under `[tool.bdt.dead_code]` in pyproject.toml:
   `.sql` files no Python code loads (`sql_roots`) and FastAPI routes that neither non-generated frontend code nor a
   `url_for(...)` call uses (`[[tool.bdt.dead_code.apps]]`: app or openapi file, frontends, excludes, optional `baseline`;

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/tests/test_lint_sql.py

@@ -377,3 +377,234 @@ async def f(cur):
     await cur.execute(q_sql)
 """
     assert "sql-inline-too-complex" in _rules(_findings(source, tmp_path / "a.py"))
+
+
+def test_fetch_all_with_fstring_is_flagged_like_execute(tmp_path: Path) -> None:
+    source = '''
+from pgdevkit.db import fetch_all
+
+async def f(table):
+    return await fetch_all(f"SELECT id FROM dim.{table} WHERE active")
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {"sql-fstring-injection"}
+
+
+def test_fetch_helpers_flag_concat_format_and_percent(tmp_path: Path) -> None:
+    source = '''
+async def f(db, value):
+    await fetch_one("select * from t where id = " + str(value))
+    await fetch_scalar("select count(*) from t where id = %s" % value)
+    await db.fetch_all("select * from t where id = {}".format(value))
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {
+        "sql-concat-injection",
+        "sql-percent-format-injection",
+        "sql-format-injection",
+    }
+
+
+def test_fetch_all_accepts_literal_load_sql_sqlglot_and_template(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import select
+from pgdevkit.db import fetch_all
+
+async def f(sql_loader, model, user_id):
+    await fetch_all(sql_loader.load_sql("users", "list_active"), {"limit": 5}, model=model)
+    await fetch_all(select("id").from_("t").sql(dialect="postgres"))
+    await fetch_all(t"select id from t where user_id = {user_id}")
+    await fetch_all("select id from t where user_id = %(id)s", {"id": user_id}, model=model)
+'''
+    assert _findings(source, tmp_path / "a.py") == []
+
+
+def test_fetch_all_applies_inline_complexity_and_positional_rules(tmp_path: Path) -> None:
+    source = '''
+async def f(model):
+    await fetch_all("select a.id from a join b on b.a_id = a.id", model=model)
+    await fetch_all("select id from t where x = %s", (1,))
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {"sql-inline-too-complex", "sql-positional-param"}
+
+
+def test_unrelated_fetch_all_name_with_non_sql_text_is_not_flagged(tmp_path: Path) -> None:
+    source = '''
+async def f(client, name):
+    return await client.fetch_all(f"users/{name}")
+'''
+    assert _findings(source, tmp_path / "a.py") == []
+
+
+def test_sqlglot_builder_with_interpolated_string_is_flagged(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import select
+import sqlglot
+
+async def f(con, user_filter, col):
+    q1 = select("id").from_("t").where(f"name = {user_filter}")
+    q2 = sqlglot.parse_one("select " + col + " from t")
+    q3 = select("id").from_("t").order_by("{} desc".format(col))
+    await fetch_all(q1.sql(dialect="postgres"))
+'''
+    findings = _findings(source, tmp_path / "a.py")
+    assert _rules(findings) == {"sql-sqlglot-string-injection"}
+    assert len(findings) == 3
+
+
+def test_sqlglot_builders_with_literals_and_nodes_are_clean(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import exp, select
+
+async def f(col):
+    q = select("id", "name").from_("dim.customer").where("active = true")
+    q = q.where(exp.column(col).eq(exp.Placeholder(this="id")))
+    q = q.order_by(exp.to_identifier(col).sql())
+    return q
+'''
+    assert _findings(source, tmp_path / "a.py") == []
+
+
+def test_sqlglot_rule_ignores_files_that_do_not_use_sqlglot(tmp_path: Path) -> None:
+    source = '''
+def f(qs, name):
+    return qs.where(f"name = {name}").select(f"x{name}")
+'''
+    assert _findings(source, tmp_path / "a.py") == []
+
+
+def test_sqlglot_method_on_a_variable_is_flagged_but_generic_join_is_not(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import select
+
+def f(user_filter, parts):
+    q = select("id").from_("t")
+    q = q.where(f"name = {user_filter}")
+    label = ", ".join(f"{p}!" for p in parts) + "".join(f"{p}" for p in parts)
+    return q, label
+'''
+    findings = _findings(source, tmp_path / "a.py")
+    assert [f.rule for f in findings] == ["sql-sqlglot-string-injection"]
+
+
+def test_sqlglot_rule_gaps_found_in_review(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import select as s, parse_one as p
+import sqlglot
+
+def f(x, y, cols, xs, m):
+    w = f"a={x}"
+    q = s("a").from_("t").where("a = " + x + y)       # 3-part concatenation
+    q = q.where(w)                                      # through a variable
+    p(f"select {x}")                                    # aliased import
+    s(*[f"{c} as {a}" for c, a in m])                   # starred comprehension
+    q.where(" and ".join(f"{c}=1" for c in cols))       # join of interpolated elements
+    return q
+'''
+    findings = _findings(source, tmp_path / "a.py")
+    assert [f.rule for f in findings] == ["sql-sqlglot-string-injection"] * 5
+    assert [f.line for f in findings] == [7, 8, 9, 10, 11]
+
+
+def test_sqlglot_rule_false_positive_guards(tmp_path: Path) -> None:
+    source = '''
+import sqlglot
+from sqlglot import select
+
+class A:
+    def go(self, c):
+        return self.where(f"{c}")
+
+def f(df, Model, session, x, d, i):
+    df.group_by(f"{x}_id")
+    Model.objects.order_by(f"-{x}")
+    session.query(A).group_by(f"{x}").having(f"{x}")
+    sqlglot.parse_one("select 1", dialect=f"{d}")
+    select("a").from_("t", alias=f"t{i}")
+    select("a").where(f"{1}")
+    select("a").where(f"a={'x'}")
+    select("a").where(f"b = {i}", dialect=d)  # the one real finding: positional f-string with a name
+'''
+    findings = _findings(source, tmp_path / "a.py")
+    assert [f.line for f in findings] == [17]
+
+
+def test_sqlglot_finding_line_is_the_offending_argument_in_a_multiline_chain(tmp_path: Path) -> None:
+    source = '''
+from sqlglot import select
+
+def f(y):
+    return (
+        select("a")
+        .from_("t")
+        .where(f"a={y}")
+    )
+'''
+    assert [f.line for f in _findings(source, tmp_path / "a.py")] == [8]
+
+
+def test_postgres_json_response_with_fstring_is_flagged_like_execute(tmp_path: Path) -> None:
+    source = '''
+from pgdevkit.fastapi import PostgresJsonResponse
+
+async def f(table):
+    return PostgresJsonResponse(f"SELECT id FROM dim.{table} WHERE active")
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {"sql-fstring-injection"}
+
+
+def test_postgres_json_response_flags_every_interpolation_form_and_call_shape(tmp_path: Path) -> None:
+    source = '''
+import pgdevkit.fastapi as pgf
+
+def f(value, table):
+    PostgresJsonResponse("select * from t where id = " + str(value))
+    PostgresJsonResponse("select * from t where id = %s" % value)
+    pgf.PostgresJsonResponse("select * from t where id = {}".format(value))
+    PostgresJsonResponse(query=f"select id from {table}", pool=None)
+'''
+    findings = _findings(source, tmp_path / "a.py")
+    assert _rules(findings) == {
+        "sql-concat-injection",
+        "sql-percent-format-injection",
+        "sql-format-injection",
+        "sql-fstring-injection",
+    }
+    assert len(findings) == 4
+
+
+def test_postgres_json_response_follows_a_variable_to_its_unsafe_assignment(tmp_path: Path) -> None:
+    source = '''
+def f(table):
+    query = f"select id from dim.{table} where active"
+    return PostgresJsonResponse(query, {"x": 1})
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {"sql-fstring-injection"}
+
+
+def test_postgres_json_response_accepts_literal_load_sql_and_named_params(tmp_path: Path) -> None:
+    source = '''
+def f(sql_loader, lng):
+    PostgresJsonResponse(sql_loader.load_sql("articles", "list_articles"), {"lng": lng})
+    PostgresJsonResponse("select id, name from articles where lng = %(lng)s", {"lng": lng})
+    PostgresJsonResponse("select 1 as a", query_produces_json=False, batch_size=10, statement_timeout=5)
+    PostgresJsonResponse(t"select id from articles where lng = {lng}")
+'''
+    assert _findings(source, tmp_path / "a.py") == []
+
+
+def test_postgres_json_response_applies_inline_complexity_and_positional_rules(tmp_path: Path) -> None:
+    source = '''
+def f():
+    PostgresJsonResponse("select a.id from a join b on b.a_id = a.id")
+    PostgresJsonResponse("select id from t where x = %s", (1,))
+'''
+    assert _rules(_findings(source, tmp_path / "a.py")) == {"sql-inline-too-complex", "sql-positional-param"}
+
+
+def test_legacy_ccmt_postgres_json_response_with_connection_first_is_not_flagged(tmp_path: Path) -> None:
+    # CCMT2's own pre-pgdevkit class takes `("postgres", sql, ...)`: its first argument is no SQL, so it stays
+    # unchecked (silently skipped, never a false positive) until that call site moves to pgdevkit's class.
+    source = '''
+def f(table):
+    return PostgresJsonResponse("postgres", f"select id from dim.{table}", parameters={})
+'''
+    assert _findings(source, tmp_path / "a.py") == []

{bmsdna_devtools-0.32.0 → bmsdna_devtools-0.34.0}/uv.lock

@@ -22,7 +22,7 @@ wheels = [
 
 [[package]]
 name = "bmsdna-devtools"
-version = "0.32.0"
+version = "0.34.0"
 source = { editable = "." }
 dependencies = [
     { name = "pgdevkit", extra = ["db"] },