dataform-sqlx-lint 0.1.0__py3-none-any.whl

dataform_sqlx_lint/__init__.py

@@ -0,0 +1,7 @@
+"""dataform-sqlx-lint: convention linter for Dataform .sqlx files."""
+
+from .config import Config, DirPolicy, load_config
+from .linter import Finding, lint_file, lint_text
+
+__all__ = ["Config", "DirPolicy", "Finding", "lint_file", "lint_text", "load_config"]
+__version__ = "0.1.0"

dataform_sqlx_lint/cli.py

@@ -0,0 +1,81 @@
+"""Command-line interface.
+
+Usage: dataform-sqlx-lint [--config PATH] [--definitions-root DIR] FILE [FILE ...]
+Exit codes: 0 = clean or warnings only, 1 = errors found, 2 = usage error.
+"""
+
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+import tomllib
+
+from .config import Config, _from_dict, load_config
+from .linter import lint_file
+
+
+def _repo_resolver(root: Path):
+    """Resolve an action name to the text of <root>/**/<name>.sqlx.
+    Used to follow `select *` through ${ref()} for E010."""
+    if not root.is_dir():
+        return lambda name: None
+    index = {p.stem: p for p in root.rglob("*.sqlx")}
+
+    def resolve(name):
+        p = index.get(name)
+        try:
+            return p.read_text(encoding="utf-8") if p else None
+        except OSError:
+            return None
+
+    return resolve
+
+
+def main(argv: list[str] | None = None) -> int:
+    parser = argparse.ArgumentParser(
+        prog="dataform-sqlx-lint",
+        description="Convention linter for Dataform .sqlx files",
+    )
+    parser.add_argument("files", nargs="+", help=".sqlx files to lint")
+    parser.add_argument(
+        "--config",
+        help="path to a TOML config file (default: .sqlx-lint.toml or "
+        "[tool.sqlx-lint] in ./pyproject.toml)",
+    )
+    parser.add_argument(
+        "--definitions-root",
+        default="definitions",
+        help="directory indexed to resolve ${ref()} targets for the E010 "
+        "coverage rule (default: ./definitions)",
+    )
+    args = parser.parse_args(argv)
+
+    if args.config:
+        cfg: Config = _from_dict(tomllib.loads(Path(args.config).read_text()))
+    else:
+        cfg = load_config(".")
+    resolver = _repo_resolver(Path(args.definitions_root))
+
+    errors = warnings = 0
+    for path in args.files:
+        try:
+            findings = lint_file(path, config=cfg, resolver=resolver)
+        except OSError as exc:
+            print(f"{path}: cannot read: {exc}")
+            errors += 1
+            continue
+        for f in sorted(findings, key=lambda f: f.line):
+            print(f"{path}:{f.line}: {f.code} [{f.severity}] {f.message}")
+            if f.severity == "error":
+                errors += 1
+            else:
+                warnings += 1
+    if errors or warnings:
+        print(f"sqlx-lint: {errors} error(s), {warnings} warning(s)")
+    return 1 if errors else 0
+
+
+def entrypoint() -> None:
+    sys.exit(main())

dataform_sqlx_lint/config.py

@@ -0,0 +1,110 @@
+"""Configuration model and TOML loading.
+
+Precedence: .sqlx-lint.toml in the working directory, else the
+[tool.sqlx-lint] table of pyproject.toml, else built-in defaults.
+"""
+
+from __future__ import annotations
+
+import tomllib
+from dataclasses import dataclass, field
+from pathlib import Path
+
+#: Rules that run unless disabled.
+DEFAULT_ENABLED = {"E001", "E002", "E003", "E004", "E006", "E007", "E010"}
+#: Opt-in rules (house-style checks): enable via `enable = [...]`.
+OPT_IN = {"E005", "W008"}
+
+
+@dataclass(frozen=True)
+class DirPolicy:
+    """Naming/type policy applied to files whose path contains a substring."""
+
+    path_contains: str
+    require_prefix: str | None = None
+    require_types: tuple[str, ...] | None = None
+    severity: str = "error"
+
+
+@dataclass(frozen=True)
+class Config:
+    schema_suffixes: list[str] = field(default_factory=lambda: ["_prod", "_dev"])
+    documented_types: set[str] = field(
+        default_factory=lambda: {"table", "view", "incremental", "declaration"}
+    )
+    #: E010 applies only to files whose path contains one of these; empty = all.
+    coverage_paths: list[str] = field(default_factory=list)
+    dir_policies: list[DirPolicy] = field(default_factory=list)
+    enabled_extra: set[str] = field(default_factory=set)
+    disabled: set[str] = field(default_factory=set)
+
+    def rule_on(self, code: str) -> bool:
+        if code in self.disabled:
+            return False
+        return code in DEFAULT_ENABLED or code in self.enabled_extra
+
+    def __eq__(self, other):
+        if not isinstance(other, Config):
+            return NotImplemented
+        return (
+            self.schema_suffixes == other.schema_suffixes
+            and self.documented_types == other.documented_types
+            and self.coverage_paths == other.coverage_paths
+            and self.dir_policies == other.dir_policies
+            and self.enabled_extra == other.enabled_extra
+            and self.disabled == other.disabled
+        )
+
+
+_KNOWN_KEYS = {
+    "schema_suffixes",
+    "documented_types",
+    "coverage_paths",
+    "dir_policies",
+    "enable",
+    "disable",
+}
+
+
+def _from_dict(raw: dict) -> Config:
+    unknown = set(raw) - _KNOWN_KEYS
+    if unknown:
+        raise ValueError(
+            f"unknown sqlx-lint config key(s): {', '.join(sorted(unknown))}"
+        )
+    policies = [
+        DirPolicy(
+            path_contains=p["path_contains"],
+            require_prefix=p.get("require_prefix"),
+            require_types=tuple(p["require_types"]) if p.get("require_types") else None,
+            severity=p.get("severity", "error"),
+        )
+        for p in raw.get("dir_policies", [])
+    ]
+    kwargs = {}
+    if "schema_suffixes" in raw:
+        kwargs["schema_suffixes"] = list(raw["schema_suffixes"])
+    if "documented_types" in raw:
+        kwargs["documented_types"] = set(raw["documented_types"])
+    if "coverage_paths" in raw:
+        kwargs["coverage_paths"] = list(raw["coverage_paths"])
+    return Config(
+        dir_policies=policies,
+        enabled_extra=set(raw.get("enable", [])),
+        disabled=set(raw.get("disable", [])),
+        **kwargs,
+    )
+
+
+def load_config(root: str | Path = ".") -> Config:
+    root = Path(root)
+    standalone = root / ".sqlx-lint.toml"
+    if standalone.is_file():
+        return _from_dict(tomllib.loads(standalone.read_text(encoding="utf-8")))
+    pyproject = root / "pyproject.toml"
+    if pyproject.is_file():
+        data = tomllib.loads(pyproject.read_text(encoding="utf-8"))
+        tool = data.get("tool", {}).get("sqlx-lint")
+        if tool is not None:
+            return _from_dict(tool)
+    return Config()

dataform_sqlx_lint/linter.py

@@ -0,0 +1,378 @@
+"""Core linter: parses the .sqlx config block and SQL body, emits Findings.
+
+Rules (codes are stable; suppress with `-- sqlx-lint: disable=E006` on the
+offending line or `-- sqlx-lint: disable-file=E006` anywhere in the file):
+
+  E001  config {} block missing or unbalanced
+  E002  columns: {} missing or empty on documented types
+  E003  schema: hardcodes an environment suffix (suffix-doubling trap)
+  E004  name: redundantly matches the filename (non-declarations)
+  E005  schema: set on operations/assertion configs        [opt-in]
+  E006  hardcoded `project.dataset.table` path instead of ${ref()}
+  E007  directory policy violation (configured prefix/type per path)
+  W008  post_operations block appears before the main SELECT [opt-in]
+  E010  columns:{} does not cover every determinable output column
+"""
+
+from __future__ import annotations
+
+import re
+from dataclasses import dataclass
+
+from .config import Config
+
+NO_SCHEMA_TYPES = {"operations", "assertion", "test"}
+
+
+@dataclass
+class Finding:
+    code: str
+    severity: str  # "error" | "warning"
+    line: int
+    message: str
+
+
+def _line_of(text, pos):
+    return text.count("\n", 0, pos) + 1
+
+
+def _balanced_block(text, open_brace_pos):
+    """Return (content, end_pos) of the brace block at open_brace_pos, else None."""
+    depth = 0
+    in_str = None
+    i = open_brace_pos
+    while i < len(text):
+        ch = text[i]
+        if in_str:
+            if ch == "\\":
+                i += 2
+                continue
+            if ch == in_str:
+                in_str = None
+        elif ch in "\"'`":
+            in_str = ch
+        elif ch == "{":
+            depth += 1
+        elif ch == "}":
+            depth -= 1
+            if depth == 0:
+                return text[open_brace_pos + 1 : i], i + 1
+        i += 1
+    return None
+
+
+def _config_value(config, key):
+    m = re.search(rf'\b{key}\s*:\s*"([^"]*)"', config)
+    return m.group(1) if m else None
+
+
+def _strip_comments(text):
+    text = re.sub(
+        r"/\*.*?\*/", lambda m: re.sub(r"[^\n]", " ", m.group(0)), text, flags=re.S
+    )
+    return re.sub(r"--[^\n]*", lambda m: " " * len(m.group(0)), text)
+
+
+def _split_top_level(text, sep=","):
+    """Split text on sep occurring outside (), [], {}, and string literals."""
+    parts, depth, start, in_str, i = [], 0, 0, None, 0
+    while i < len(text):
+        ch = text[i]
+        if in_str:
+            if ch == "\\":
+                i += 2
+                continue
+            if ch == in_str:
+                in_str = None
+        elif ch in "\"'`":
+            in_str = ch
+        elif ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+        elif ch == sep and depth == 0:
+            parts.append(text[start:i])
+            start = i + 1
+        i += 1
+    parts.append(text[start:])
+    return parts
+
+
+def _main_projection(clean_body):
+    """Return (projection_text, from_clause_text, select_pos) of the first
+    top-level SELECT (CTE bodies and sub-selects sit inside parens/braces),
+    or None if no top-level SELECT exists."""
+    depth, in_str, i = 0, None, 0
+    select_pos = None
+    while i < len(clean_body):
+        ch = clean_body[i]
+        if in_str:
+            if ch == "\\":
+                i += 2
+                continue
+            if ch == in_str:
+                in_str = None
+        elif ch in "\"'`":
+            in_str = ch
+        elif ch in "([{":
+            depth += 1
+        elif ch in ")]}":
+            depth -= 1
+        elif depth == 0 and ch in "sSfF":
+            word = re.match(r"(select|from)\b", clean_body[i:], re.I)
+            if word and (
+                i == 0 or not (clean_body[i - 1].isalnum() or clean_body[i - 1] in "_$")
+            ):
+                if word.group(1).lower() == "select" and select_pos is None:
+                    select_pos = i
+                elif word.group(1).lower() == "from" and select_pos is not None:
+                    return (clean_body[select_pos + 6 : i], clean_body[i:], select_pos)
+        i += 1
+    if select_pos is not None:  # SELECT without FROM (constants)
+        return (clean_body[select_pos + 6 :], "", select_pos)
+    return None
+
+
+_SIMPLE_IDENT = re.compile(r"^`?[A-Za-z_]\w*`?(?:\.`?([A-Za-z_]\w*)`?)?$")
+_TRAILING_ALIAS = re.compile(r"\bas\s+`?([A-Za-z_]\w*)`?\s*$", re.I | re.S)
+_STAR_ITEM = re.compile(
+    r"^(?:[A-Za-z_]\w*\.)?\*\s*(?:except\s*\(([^)]*)\))?\s*(?:replace\s*\(.*\))?$",
+    re.I | re.S,
+)
+_SINGLE_REF_FROM = re.compile(
+    r"^from\s+\$\{\s*ref\(\s*(?:\"[^\"]*\"\s*,\s*)?\"([^\"]+)\"\s*\)\s*\}\s*"
+    r"(?:as\s+\w+\s*)?"
+    r"(?:where\b|group\b|order\b|qualify\b|limit\b|window\b|post_operations\b|$)",
+    re.I | re.S,
+)
+
+
+def _known_output_columns(clean_body, resolver, _depth=0, _seen=None):
+    """Best-effort set of output column names of a file's main SELECT.
+    Unparseable items are silently skipped; `select *` is followed through a
+    single plain ${ref()} when a resolver is provided. Never raises."""
+    parsed = _main_projection(clean_body)
+    if parsed is None:
+        return set()
+    projection, from_clause, _ = parsed
+    names, star_except = set(), None
+    items = _split_top_level(projection)
+    if items:
+        items[0] = re.sub(r"^\s*(distinct|all)\b", "", items[0], flags=re.I)
+    for item in items:
+        item = item.strip()
+        if not item:
+            continue
+        sm = _STAR_ITEM.match(item)
+        if sm:
+            star_except = {
+                n.strip().strip("`").lower()
+                for n in (sm.group(1) or "").split(",")
+                if n.strip()
+            }
+            continue
+        am = _TRAILING_ALIAS.search(item)
+        if am:
+            names.add(am.group(1).lower())
+            continue
+        im = _SIMPLE_IDENT.match(item)
+        if im:
+            names.add((im.group(1) or item.strip("`")).lower())
+    if star_except is not None and resolver is not None and _depth < 3:
+        rm = _SINGLE_REF_FROM.match(from_clause.strip())
+        if rm:
+            ref_name = rm.group(1)
+            _seen = _seen or set()
+            if ref_name not in _seen:
+                _seen.add(ref_name)
+                upstream = resolver(ref_name)
+                if upstream is not None:
+                    up_names = _known_output_columns(
+                        _strip_comments(upstream), resolver, _depth + 1, _seen
+                    )
+                    names |= up_names - star_except
+    return names
+
+
+def _documented_keys(config):
+    """Top-level keys of the columns:{} block, lowercased; empty set if none."""
+    cm = re.search(r"\bcolumns\s*:\s*({)", config)
+    block = _balanced_block(config, cm.start(1)) if cm else None
+    if not block:
+        return set()
+    keys = set()
+    for item in _split_top_level(block[0]):
+        km = re.match(r'\s*"?([A-Za-z_]\w*)"?\s*:', item)
+        if km:
+            keys.add(km.group(1).lower())
+    return keys
+
+
+def lint_text(text, path, config: Config | None = None, resolver=None):
+    cfg = config or Config()
+    findings: list[Finding] = []
+    path = path.replace("\\", "/")
+    stem = re.sub(r"\.sqlx$", "", path.rsplit("/", 1)[-1])
+    file_disabled = set(re.findall(r"sqlx-lint:\s*disable-file=([EW]\d+)", text))
+    lines = text.split("\n")
+
+    def suppressed(code, line):
+        if code in file_disabled:
+            return True
+        return (
+            line - 1 < len(lines)
+            and f"disable={code}" in lines[line - 1]
+            and "sqlx-lint:" in lines[line - 1]
+        )
+
+    def add(code, severity, line, message):
+        if cfg.rule_on(code) and not suppressed(code, line):
+            findings.append(Finding(code, severity, line, message))
+
+    # --- E001: locate and parse config block ---
+    m = re.search(r"\bconfig\s*({)", text)
+    if not m:
+        add("E001", "error", 1, "no config {} block found")
+        return findings
+    block = _balanced_block(text, m.start(1))
+    if block is None:
+        add(
+            "E001",
+            "error",
+            _line_of(text, m.start()),
+            "config {} block braces are unbalanced",
+        )
+        return findings
+    config_body, config_end = block
+    config_line = _line_of(text, m.start())
+    body = text[config_end:]
+    body_offset = config_end
+
+    ctype = _config_value(config_body, "type") or ""
+    schema = _config_value(config_body, "schema")
+    name = _config_value(config_body, "name")
+    documented = _documented_keys(config_body)
+
+    # --- E002: columns documentation ---
+    if ctype in cfg.documented_types and not documented:
+        add(
+            "E002",
+            "error",
+            config_line,
+            f'type "{ctype}" requires a non-empty columns: {{}} block',
+        )
+
+    # --- E003: schema suffix (declarations exempt: raw datasets may carry one) ---
+    suffix_re = "|".join(re.escape(s) for s in cfg.schema_suffixes)
+    if (
+        schema
+        and cfg.schema_suffixes
+        and ctype != "declaration"
+        and re.search(rf"(?:{suffix_re})$", schema)
+    ):
+        sm = re.search(r'\bschema\s*:\s*"', config_body)
+        base = re.sub(rf"(?:{suffix_re})$", "", schema)
+        add(
+            "E003",
+            "error",
+            config_line + config_body[: sm.start()].count("\n"),
+            f'schema: "{schema}" hardcodes an environment suffix; use the '
+            f'base name ("{base}") and let --schema-suffix append it',
+        )
+
+    # --- E004: redundant name (declarations conventionally repeat it) ---
+    if name and ctype != "declaration" and name == stem:
+        nm = re.search(r'\bname\s*:\s*"', config_body)
+        add(
+            "E004",
+            "error",
+            config_line + config_body[: nm.start()].count("\n"),
+            f'name: "{name}" matches the filename and is redundant — remove it',
+        )
+
+    # --- E005 (opt-in): schema on operations/assertions ---
+    # hasOutput: true operations are exempt: schema+name define ${self()}.
+    has_output = re.search(r"\bhasOutput\s*:\s*true\b", config_body) is not None
+    if schema and ctype in NO_SCHEMA_TYPES and not has_output:
+        add(
+            "E005",
+            "error",
+            config_line,
+            f'type "{ctype}" must not set schema: — '
+            "it uses the workflow_settings.yaml default",
+        )
+
+    # --- E006: hardcoded table paths in the SQL body ---
+    clean_body = _strip_comments(body)
+    for pm in re.finditer(r"`([A-Za-z][\w-]*\.[A-Za-z]\w*\.[A-Za-z]\w*)`", clean_body):
+        if "${" in pm.group(0):
+            continue
+        add(
+            "E006",
+            "error",
+            _line_of(text, body_offset + pm.start()),
+            f"hardcoded table path `{pm.group(1)}` — "
+            "declare a source and use ${ref()}",
+        )
+
+    # --- E007: directory policies ---
+    for policy in cfg.dir_policies:
+        if policy.path_contains not in path:
+            continue
+        if policy.require_prefix and not stem.startswith(policy.require_prefix):
+            add(
+                "E007",
+                policy.severity,
+                1,
+                f"files in {policy.path_contains} must be prefixed "
+                f'"{policy.require_prefix}" (got "{stem}")',
+            )
+        if policy.require_types and ctype not in policy.require_types:
+            add(
+                "E007",
+                policy.severity,
+                config_line,
+                f"files in {policy.path_contains} must be type "
+                f'{" or ".join(policy.require_types)} (got "{ctype}")',
+            )
+
+    # --- E010: columns coverage (skip when E002 already owns the file) ---
+    in_scope = not cfg.coverage_paths or any(
+        p in path for p in cfg.coverage_paths
+    )
+    if ctype in ("table", "incremental", "view") and documented and in_scope:
+        known = _known_output_columns(clean_body, resolver)
+        missing = sorted(known - documented)
+        if missing:
+            parsed = _main_projection(clean_body)
+            sel_line = (
+                _line_of(text, body_offset + parsed[2]) if parsed else config_line
+            )
+            shown = ", ".join(f'"{n}"' for n in missing[:10])
+            more = f" (+{len(missing) - 10} more)" if len(missing) > 10 else ""
+            add(
+                "E010",
+                "error",
+                sel_line,
+                f"columns: {{}} is missing documentation for output "
+                f"column(s): {shown}{more}",
+            )
+
+    # --- W008 (opt-in): post_operations placement ---
+    pm = re.search(r"\bpost_operations\s*{", body)
+    if pm:
+        sm = re.search(r"(?im)^\s*select\b", _strip_comments(body[: pm.start()]))
+        if sm is None:
+            add(
+                "W008",
+                "warning",
+                _line_of(text, body_offset + pm.start()),
+                "post_operations {} placed before the main SELECT statement",
+            )
+
+    return findings
+
+
+def lint_file(path, config: Config | None = None, resolver=None):
+    with open(path, encoding="utf-8") as fh:
+        return lint_text(fh.read(), path, config=config, resolver=resolver)

dataform_sqlx_lint-0.1.0.dist-info/METADATA

@@ -0,0 +1,124 @@
+Metadata-Version: 2.4
+Name: dataform-sqlx-lint
+Version: 0.1.0
+Summary: Convention linter for Dataform .sqlx files — checks the config-block and project conventions that SQL linters cannot see
+Author-email: Ivan Histand <ihistand@rotoplas.com>
+License-Expression: MIT
+Project-URL: Homepage, https://github.com/acuantia/dataform-sqlx-lint
+Keywords: dataform,sqlx,lint,bigquery,pre-commit
+Classifier: Development Status :: 4 - Beta
+Classifier: Environment :: Console
+Classifier: Programming Language :: Python :: 3
+Classifier: Topic :: Software Development :: Quality Assurance
+Requires-Python: >=3.11
+Description-Content-Type: text/markdown
+License-File: LICENSE
+Dynamic: license-file
+
+# dataform-sqlx-lint
+
+A convention linter for [Dataform](https://cloud.google.com/dataform) `.sqlx`
+files. SQL linters (sqlfluff) check the SQL body; `dataform compile` checks
+syntax. Neither sees the **config-block and project conventions** that keep a
+Dataform repo healthy — this tool does.
+
+Zero dependencies (Python ≥ 3.11 standard library only). Designed for
+[pre-commit](https://pre-commit.com).
+
+```bash
+pip install dataform-sqlx-lint
+```
+
+## Rules
+
+| Code | Default | Checks |
+|------|---------|--------|
+| E001 | on | `config {}` block present and balanced |
+| E002 | on | non-empty `columns: {}` documentation on tables/views/incrementals/declarations |
+| E003 | on | `schema:` must not hardcode an environment suffix (`_prod`/`_dev` by default) — `--schema-suffix` appends it, so a literal doubles up (`looker_prod_prod`) |
+| E004 | on | `name:` matching the filename is redundant (declarations exempt) |
+| E005 | opt-in | operations/assertions must not set `schema:` (`hasOutput: true` operations exempt — schema+name define `${self()}`) |
+| E006 | on | hardcoded `` `project.dataset.table` `` paths instead of `${ref()}` — these silently break Dataform's dependency graph |
+| E007 | on* | configurable per-directory naming/type policies (*no-op until policies are configured) |
+| W008 | opt-in | `post_operations {}` placed before the main SELECT (style preference; Dataform accepts either) |
+| E010 | on | every determinable output column appears in `columns: {}` — parses the main SELECT conservatively (unparseable expressions are skipped, never false-flagged) and follows `select *` through a single plain `${ref()}` into the upstream file |
+
+Why E010 matters: `columns: {}` is what Dataform writes to BigQuery column
+descriptions — the metadata data catalogs, BI tools, and AI/conversational
+analytics agents read. Partial blocks leave silent gaps.
+
+## Usage
+
+```bash
+dataform-sqlx-lint definitions/output/my_table.sqlx [...]
+# exit 0 = clean or warnings only; 1 = errors
+```
+
+Run from the repo root so `--definitions-root` (default `./definitions`) can
+index `${ref()}` targets for E010's star-resolution.
+
+### pre-commit
+
+```yaml
+repos:
+  - repo: https://github.com/acuantia/dataform-sqlx-lint
+    rev: v0.1.0
+    hooks:
+      - id: dataform-sqlx-lint
+```
+
+### Configuration
+
+`.sqlx-lint.toml` in the repo root, or a `[tool.sqlx-lint]` table in
+`pyproject.toml` (the standalone file wins). All keys optional:
+
+```toml
+schema_suffixes = ["_prod", "_dev"]        # E003 suffix list ([] disables)
+documented_types = ["table", "view", "incremental", "declaration"]  # E002
+coverage_paths = ["definitions/output/"]   # E010 scope; empty = everywhere
+enable = ["E005", "W008"]                  # switch on opt-in rules
+disable = ["E004"]                         # switch off default rules
+
+[[dir_policies]]                           # E007 (repeatable)
+path_contains = "definitions/output/looker/"
+require_prefix = "looker_"
+require_types = ["table", "incremental"]
+severity = "error"                         # or "warning"
+```
+
+See `examples/acuantia.sqlx-lint.toml` for a complete real-world config.
+
+### Suppressing findings
+
+```sql
+from `proj.raw_api.events` -- sqlx-lint: disable=E006 (declaration repoints at cutover)
+```
+
+or file-wide, anywhere in the file:
+
+```sql
+-- sqlx-lint: disable-file=E006
+```
+
+Suppress with a reason, sparingly — the convention is usually the fix.
+
+## Design notes
+
+- **Conservative by construction**: the SQL projection parser only claims
+  column names it can determine (aliases, simple identifiers, resolvable
+  `select *`); anything ambiguous is skipped, so E010 never false-flags.
+- **Declarations are exempt** from E003/E004 deliberately: raw source datasets
+  legitimately carry environment-suffixed names, and Dataform requires `name:`
+  on declarations.
+- Rule codes are stable; gaps in the numbering are historical.
+
+## Development
+
+```bash
+python3 -m venv .venv && .venv/bin/pip install -e . pytest
+.venv/bin/pytest        # 53 tests
+```
+
+## License
+
+MIT — see [LICENSE](LICENSE).

dataform_sqlx_lint-0.1.0.dist-info/RECORD

@@ -0,0 +1,10 @@
+dataform_sqlx_lint/__init__.py,sha256=rrjJ-9Htqn9zU92rxLEJWBGe4Fo6YMLcYu086V8ithY,281
+dataform_sqlx_lint/cli.py,sha256=lrrzJHlT8bfwy-bfkMEFGrOwJpF7H2R21aJK1QZTc0A,2426
+dataform_sqlx_lint/config.py,sha256=gorcj1Rv1nPiQVyMXlLOItGsjCSxVUD6ymVvPz5s3tI,3624
+dataform_sqlx_lint/linter.py,sha256=RFZUShjN5nSa0C-m-4jPOBfMKlVehFTIxUeg4_RDQ0Q,13089
+dataform_sqlx_lint-0.1.0.dist-info/licenses/LICENSE,sha256=LwjbOvYxlORpP0d7u3F_KRTjhPzP04XblKIKuTtC3gw,1065
+dataform_sqlx_lint-0.1.0.dist-info/METADATA,sha256=jPy56Yhrx0T_BBN3rE1KJZsUbozP7e7qiy_Wcy5gTqE,4744
+dataform_sqlx_lint-0.1.0.dist-info/WHEEL,sha256=YVMoNqKzERt-wjUZwJ33xBGAwnFl-4cqbYkTtWa4itE,91
+dataform_sqlx_lint-0.1.0.dist-info/entry_points.txt,sha256=uoj3vFX4zQpXe6QO6alBfbWjSpF8zNiot6qyESmlAFI,73
+dataform_sqlx_lint-0.1.0.dist-info/top_level.txt,sha256=xsaISCF9odSTXlB9lZwyuHW3cGF3BpznttdE88XkaPA,19
+dataform_sqlx_lint-0.1.0.dist-info/RECORD,,

dataform_sqlx_lint-0.1.0.dist-info/WHEEL

@@ -0,0 +1,5 @@
+Wheel-Version: 1.0
+Generator: setuptools (84.0.0)
+Root-Is-Purelib: true
+Tag: py3-none-any
+

dataform_sqlx_lint-0.1.0.dist-info/entry_points.txt

@@ -0,0 +1,2 @@
+[console_scripts]
+dataform-sqlx-lint = dataform_sqlx_lint.cli:entrypoint

dataform_sqlx_lint-0.1.0.dist-info/licenses/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Acuantia
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

dataform_sqlx_lint-0.1.0.dist-info/top_level.txt

@@ -0,0 +1 @@
+dataform_sqlx_lint