alterdb 0.2.0__tar.gz → 0.2.2__tar.gz

{alterdb-0.2.0 → alterdb-0.2.2}/CHANGELOG.md

@@ -2,6 +2,59 @@
 
 All notable changes to Alter are documented here.
 
+## [0.2.2] — 2026-03-15
+
+### Bug Fixes
+
+#### `alter apply` now removes deleted tables and columns from code (Bug 09)
+
+`alter apply` (and `apply_to_code` via MCP) previously ignored deletions — removing a table or column from the canvas and running `alter apply` would report "No changes — files are already up to date." while the Python class or field remained in the model file untouched. Four layers were involved:
+
+1. **Column deletion — update detection** (`generators/_surgical.py` · `_class_needs_update`): the function only checked that schema columns were present in the file, never the reverse. A `Field()`-style column that existed in the file but had been removed from the schema was silently skipped. Added a reverse check: if any `Field()` / `mapped_column()` column in the file is absent from the schema, the class is flagged for update. Bare annotations (`name: str`) are intentionally excluded from this check — they may be non-ORM helper attributes and should never be auto-deleted.
+
+2. **Column deletion — patch logic** (`generators/_surgical.py` · `_surgical_patch_class`): when walking source lines, a `Field()`-style column not found in `schema_map` fell into the "keep verbatim" branch — indistinguishable from an unchanged field. Restructured the branch: `col_name in schema_map` → keep or rebuild as before; `col_name not in schema_map` → omit from output (deleted). `last_field_result_idx` is now only updated when output is actually produced, so new-column insertion remains correctly positioned after the last kept field.
+
+3. **Table deletion** (`generators/sqlmodel.py`, `generators/sqlalchemy.py` · `update_models`): classes present in the file but absent from the schema were unconditionally skipped with a "leave untouched" comment. Now uses `tablename_to_class` (which maps `__tablename__` string → class name) to identify genuine ORM table classes. If a class has `__tablename__` and its table was deleted from the schema, it is removed from the file. Mixins, base classes, and helper classes without `__tablename__` are always left untouched.
+
+4. **File discovery** (`mcp_server.py` · `_apply_to_code_impl`, `cli.py` · `apply`): `file_groups` was built only from `schema.tables`, so a file whose last table was deleted was never visited at all. Both the CLI `apply` command and `_apply_to_code_impl` now scan the project root for ORM-containing `.py` files (using the parser's `detect_orm()`) and add any file not already in `file_groups` with an empty table list, ensuring `update_models()` is called and can remove the deleted class. Virtual environments, `__pycache__`, and other non-source directories are skipped.
+
+`alter apply --preview` correctly shows deleted fields and classes as red lines in the unified diff before any files are written.
+
+---
+
+#### MCP `undo`/`redo` always reported "Nothing to undo/redo" even after changes (Bug 01)
+
+`undo()` and `redo()` in `StagingManager` return `None` both when the stack is empty and when the operation succeeds but reverts the schema to its original state. The MCP tool handlers checked the return value to distinguish the two cases, which was unreliable. Added explicit `can_undo()` and `can_redo()` methods to `StagingManager` and changed the tool handlers to check those before calling `undo()`/`redo()`.
+
+#### Duplicate relations when tables are defined across multiple files (Bug 02)
+
+`parse_directory()` in both the SQLModel and SQLAlchemy parsers accumulated `Relation` objects across all scanned files without deduplication. When a table (and its relations) appeared in more than one file — e.g. a base model re-exported from a package `__init__.py` — the schema ended up with duplicate relation entries, which produced broken Mermaid diagrams and duplicate `FOREIGN KEY` clauses in SQL export. Added `deduplicate_relations()` to `parsers/base.py` (mirroring the existing `deduplicate_tables()`), which keeps the first definition of each relation name and also prunes orphaned relations whose source table was itself dropped by deduplication. Both parsers now call it immediately after `deduplicate_tables()`.
+
+#### MCP tool errors returned `isError: false` (Bug 05)
+
+All `except` branches in `mcp_server.py` tool handlers returned error strings (`return f"Error: {exc}"`) instead of raising. FastMCP's internal error chain only sets `isError: true` on the MCP response when the tool function raises an exception; returning a string always produces `isError: false`, so AI assistants had no reliable way to detect failures. All 17 return-error patterns replaced with `raise` (re-raise in `except` blocks) or `raise ValueError(...)` (inline guards). The 27 affected tests in `test_mcp_server.py` updated to use `pytest.raises`.
+
+#### `alter sync`/`alter diff` scan the wrong directory on multi-file projects (Bug 07)
+
+`_find_model_dirs()` in `cli.py` selected the first existing directory from a candidate list (`app/models`, `app/`, `src/`, `cwd`) without checking whether the directory contained any Python files. An empty `app/` directory would win over the project root even if all models were in `cwd`. Two-part fix: (1) `_find_model_dirs()` now requires at least one `.py` file (recursive, skipping venv/cache dirs) via a new `_has_py_files()` helper — empty directories are excluded. (2) `sync` and `diff` commands now use the `file_path` values recorded in `schema.tables` as the primary source of truth when tables are already tracked, falling back to the directory heuristic only for empty schemas. `alter init` also now records the most common model file path in `schema.metadata.sqlmodel_module` rather than using a hardcoded `"app/models.py"` default.
+
+---
+
+## [0.2.1] — 2026-03-14
+
+### Bug Fixes
+
+#### CSRF: canvas server replaced wildcard CORS with canvas-specific origin
+`Access-Control-Allow-Origin: *` allowed any website visited in the user's browser to make cross-origin requests to the canvas server's mutating endpoints (e.g. `/api/commit`, `/api/apply-to-code`). The server now reflects its own origin (`http://127.0.0.1:{port}`) in the ACAO header and adds `Vary: Origin`, so browser preflight checks block requests from other origins.
+
+#### Mermaid exporter: `FK,UK` now both emitted for FK+unique columns
+An `elif` on the unique check meant columns that are both a foreign key and unique (one-to-one relationship pattern) only showed `FK` in the diagram. Changed to `if` so both `FK` and `UK` attributes are emitted.
+
+#### SQL importer: parenthesized DEFAULT expressions with spaces now captured correctly
+`DEFAULT (1 + 2)` and `DEFAULT (CURRENT_TIMESTAMP AT TIME ZONE 'UTC')` were truncated to just the first token because the `\S+` fallback stopped at the first space. Two-part fix: (1) `_DEFAULT_RE` now includes a parenthesized-expression branch `\((?:[^()]*|\([^()]*\))*\)` that handles one level of nesting; (2) the regex is now applied to the original `defn` string rather than the post-processed `rest`, because `_COL_DEF_RE`'s optional size group was silently stripping parentheses from DEFAULT expressions before `rest` was assembled.
+
+---
+
 ## [0.2.0] — 2026-03-14
 
 ### New Features

{alterdb-0.2.0 → alterdb-0.2.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: alterdb
-Version: 0.2.0
+Version: 0.2.2
 Summary: Visual schema design for SQLModel and SQLAlchemy. Edit your database as a diagram, write it back as code.
 Project-URL: Homepage, https://github.com/chimi-labs/alter
 Project-URL: Repository, https://github.com/chimi-labs/alter
@@ -160,9 +160,13 @@ alter apply --preview   # see exactly what will change (unified diff)
 alter apply             # write the changes to your model files
 ```
 
-`alter apply` is surgical — it only modifies the classes that changed. Your docstrings,
-`Relationship()` definitions, trailing inline comments, hand-written `Field()` kwarg order,
-and mutable defaults written as `default={}` or `default=[]` are all preserved verbatim.
+`alter apply` is surgical — it only touches what the schema says has changed:
+
+- **Additions** — new tables are appended as new classes; new columns are inserted after the last existing field.
+- **Modifications** — changed `Field()` kwargs are rebuilt in-place, preserving your original kwarg order, multi-line formatting, and inline comments.
+- **Deletions** — tables removed from the canvas have their class deleted from the model file; columns removed from a table have their `Field()` line removed. If a file's last table is deleted, the file is still visited and the class is removed.
+
+Your docstrings, `Relationship()` definitions, trailing inline comments, hand-written `Field()` kwarg order, and mutable defaults written as `default={}` or `default=[]` are all preserved verbatim.
 
 For example, drawing a `Payment` table on the canvas and clicking **Commit** writes this to
 `app/models.py`:

{alterdb-0.2.0 → alterdb-0.2.2}/README.md

@@ -130,9 +130,13 @@ alter apply --preview   # see exactly what will change (unified diff)
 alter apply             # write the changes to your model files
 ```
 
-`alter apply` is surgical — it only modifies the classes that changed. Your docstrings,
-`Relationship()` definitions, trailing inline comments, hand-written `Field()` kwarg order,
-and mutable defaults written as `default={}` or `default=[]` are all preserved verbatim.
+`alter apply` is surgical — it only touches what the schema says has changed:
+
+- **Additions** — new tables are appended as new classes; new columns are inserted after the last existing field.
+- **Modifications** — changed `Field()` kwargs are rebuilt in-place, preserving your original kwarg order, multi-line formatting, and inline comments.
+- **Deletions** — tables removed from the canvas have their class deleted from the model file; columns removed from a table have their `Field()` line removed. If a file's last table is deleted, the file is still visited and the class is removed.
+
+Your docstrings, `Relationship()` definitions, trailing inline comments, hand-written `Field()` kwarg order, and mutable defaults written as `default={}` or `default=[]` are all preserved verbatim.
 
 For example, drawing a `Payment` table on the canvas and clicking **Commit** writes this to
 `app/models.py`:

{alterdb-0.2.0 → alterdb-0.2.2}/pyproject.toml

@@ -1,6 +1,6 @@
 [project]
 name = "alterdb"
-version = "0.2.0"
+version = "0.2.2"
 description = "Visual schema design for SQLModel and SQLAlchemy. Edit your database as a diagram, write it back as code."
 license = "MIT"
 license-files = ["LICENSE"]

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/canvas/server.py

@@ -374,16 +374,26 @@ class _Handler(BaseHTTPRequestHandler):
 
     # ── CORS ─────────────────────────────────────────────────────────────────
 
+    def _canvas_origin(self) -> str:
+        """Return the canvas server's own origin, e.g. ``http://127.0.0.1:8080``."""
+        host, port = self.server.server_address
+        return f"http://{host}:{port}"
+
     def _send_cors_headers(self) -> None:
-        """Append CORS headers so cross-origin clients can access the API.
+        """Append CORS headers that restrict access to the canvas origin only.
+
+        Using ``Access-Control-Allow-Origin: *`` would allow any website the
+        user visits to make cross-origin requests to mutating endpoints (CSRF).
+        Reflecting the server's own origin means only requests that the canvas
+        page itself initiates will pass the browser's preflight check.
 
-        The server already binds to 127.0.0.1 only, so ``*`` is safe here —
-        it allows the canvas UI (which may be served from a different local
-        port during development) and browser extensions to reach the API.
+        ``Vary: Origin`` is included so that caches do not serve a response
+        cached for one origin to a different origin.
         """
-        self.send_header("Access-Control-Allow-Origin", "*")
+        self.send_header("Access-Control-Allow-Origin", self._canvas_origin())
         self.send_header("Access-Control-Allow-Methods", "GET, POST, OPTIONS")
         self.send_header("Access-Control-Allow-Headers", "Content-Type")
+        self.send_header("Vary", "Origin")
 
     def do_OPTIONS(self) -> None:  # noqa: N802
         """Handle CORS preflight requests."""

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/cli.py

@@ -102,15 +102,33 @@ def _detect_orm(cwd: Path) -> str:
     return "sqlmodel"  # safe default
 
 
+def _has_py_files(directory: Path) -> bool:
+    """Return True if *directory* contains at least one .py file (recursive).
+
+    Skips virtual-environment and cache directories so that an ``app/``
+    containing only a ``.venv`` subtree is not treated as a model directory.
+    Short-circuits on the first match for speed.
+    """
+    for f in directory.rglob("*.py"):
+        if not any(part in _SKIP_DIRS for part in f.parts):
+            return True
+    return False
+
+
 def _find_model_dirs(cwd: Path) -> list[Path]:
-    """Return candidate model directories to scan."""
+    """Return candidate model directories that contain Python source files.
+
+    Checks only whether a directory exists AND has at least one ``.py`` file
+    (ignoring virtual-environment / cache subtrees).  This prevents an empty
+    ``app/`` directory from being chosen over the project root.
+    """
     candidates = [
         cwd / "app" / "models",
         cwd / "app",
         cwd / "src",
         cwd,
     ]
-    return [d for d in candidates if d.is_dir()]
+    return [d for d in candidates if d.is_dir() and _has_py_files(d)]
 
 
 def _load_demo_schema() -> Path:
@@ -220,6 +238,15 @@ def init(orm_override: str | None, output: str | None, force: bool) -> None:
 
     from alter.layout import auto_layout_tables
     auto_layout_tables(result.schema.tables)
+
+    # Record the most-used model file as sqlmodel_module so that
+    # 'alter import' knows where to put new SQL-imported tables.
+    # Only override the default when we actually found model files.
+    file_paths = [t.file_path for t in result.schema.tables if t.file_path]
+    if file_paths:
+        from collections import Counter
+        result.schema.metadata.sqlmodel_module = Counter(file_paths).most_common(1)[0][0]
+
     result.schema.save(out_path)
     click.echo(
         f"  Created {out_path.name} — "
@@ -258,8 +285,16 @@ def sync(alter_file: str | None, model_dir: str | None) -> None:
     cwd = path.parent
     scan_dir = Path(model_dir) if model_dir else None
     if scan_dir is None:
-        dirs = _find_model_dirs(cwd)
-        scan_dir = dirs[0] if dirs else cwd
+        # If the schema already has tables with recorded file paths, scan from
+        # the project root so that all model files are found regardless of
+        # directory structure — and new files added outside the original
+        # location are picked up too.  Fall back to the directory heuristic
+        # only for schemas with no tables (e.g. first sync on an empty schema).
+        if any(t.file_path for t in current.tables):
+            scan_dir = cwd
+        else:
+            dirs = _find_model_dirs(cwd)
+            scan_dir = dirs[0] if dirs else cwd
     try:
         from alter.parsers.base import get_parser
         parser = get_parser(current.orm, project_root=cwd)
@@ -408,6 +443,18 @@ def apply(alter_file: str | None, preview: bool) -> None:
         fp = t.file_path or _default_model_path(schema, project_root)
         file_groups.setdefault(fp, []).append(t)
 
+    # Also discover model files on disk that are NOT already in file_groups.
+    # These may contain table classes whose schema entries were deleted — we
+    # must visit them so update_models() can remove the deleted classes.
+    from alter.parsers.base import get_parser as _get_parser  # noqa: PLC0415
+    _file_parser = _get_parser(schema.orm, project_root=project_root)
+    for _py_file in sorted(project_root.rglob("*.py")):
+        if any(part in _SKIP_DIRS for part in _py_file.parts):
+            continue
+        _rel = str(_py_file.relative_to(project_root))
+        if _rel not in file_groups and _file_parser.detect_orm(_py_file):
+            file_groups[_rel] = []
+
     changed = 0
     default_path = _default_model_path(schema, project_root)
     for rel_path, tables in sorted(file_groups.items()):
@@ -491,8 +538,11 @@ def diff(alter_file: str | None, fmt: str) -> None:
         raise click.ClickException(str(exc)) from exc
 
     cwd = path.parent
-    dirs = _find_model_dirs(cwd)
-    scan_dir = dirs[0] if dirs else cwd
+    if any(t.file_path for t in current.tables):
+        scan_dir = cwd
+    else:
+        dirs = _find_model_dirs(cwd)
+        scan_dir = dirs[0] if dirs else cwd
     try:
         from alter.parsers.base import get_parser
         parser = get_parser(current.orm, project_root=cwd)

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/exporters/mermaid.py

@@ -94,6 +94,6 @@ def _col_attr(col: Column) -> str:
         attrs.append("PK")
     if col.foreign_key:
         attrs.append("FK")
-    elif col.unique and not col.primary_key:
+    if col.unique and not col.primary_key:
         attrs.append("UK")
     return (" " + ",".join(attrs)) if attrs else ""

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/exporters/sql.py

@@ -148,5 +148,6 @@ def _format_default(default: str) -> str | None:
         return default
     except ValueError:
         pass
-    # String literal — wrap in single quotes
-    return f"'{default}'"
+    # String literal — wrap in single quotes, doubling any internal quotes
+    # (standard SQL escaping: don't → 'don''t').
+    return "'{}'".format(default.replace("'", "''"))

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/generators/_surgical.py

@@ -562,6 +562,19 @@ def _class_needs_update(class_source: str, schema_field_lines: list[str]) -> boo
         else:
             return True  # genuinely new column
 
+    # Reverse check: if any Field()-style column in the file is NOT in the
+    # schema, the class needs updating (that column was deleted from the schema).
+    # We intentionally do NOT check bare annotations here — those may be
+    # hand-written non-ORM helper attributes and should never be auto-deleted.
+    schema_col_names = {
+        c
+        for line in schema_field_lines
+        if (c := _col_name_from_generated(line)) is not None
+    }
+    for col_name, _, _ in stmts:
+        if col_name not in schema_col_names:
+            return True
+
     return False
 
 
@@ -636,19 +649,26 @@ def _surgical_patch_class(
                     result.append(indent_str + new_line + "\n")
                 else:
                     # Bare field is equivalent or not in schema — keep verbatim.
+                    # We never auto-delete bare annotations: they may be non-ORM
+                    # helper attributes, not managed schema columns.
                     for ln in src_lines[i:end]:
                         result.append(ln)
+                # Bare branch always produces output — update insertion marker.
+                last_field_result_idx = len(result) - 1
             else:
                 if col_name in schema_map and not _field_kwargs_equal(existing_text, schema_map[col_name]):
                     # Rebuild with original kwarg order / multi-line style / LHS preserved
                     rebuilt = _rebuild_field_line(existing_text, schema_map[col_name])
                     result.append(rebuilt.rstrip() + "\n")
-                else:
+                    last_field_result_idx = len(result) - 1
+                elif col_name in schema_map:
                     # Keep verbatim (unchanged field — preserves kwarg order and formatting)
                     for ln in src_lines[i:end]:
                         result.append(ln)
-
-            last_field_result_idx = len(result) - 1
+                    last_field_result_idx = len(result) - 1
+                # else: col_name not in schema_map → column deleted from schema;
+                # omit from output.  Do NOT update last_field_result_idx so that
+                # any new columns are still inserted after the last kept field.
             i = end
         else:
             result.append(src_lines[i])

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/generators/sqlalchemy.py

@@ -103,9 +103,9 @@ def _mapped_column_args(col: Column, enum_names: set[str]) -> str:
         args.append("default=lambda: datetime.now(timezone.utc)")
     elif col.default == "now":
         args.append("default=datetime.now")
-    elif col.default == "{}":
+    elif col.default in ("dict", "{}"):
         args.append("default=dict")
-    elif col.default == "[]":
+    elif col.default in ("list", "[]"):
         args.append("default=list")
     elif col.default is not None:
         raw = col.default
@@ -305,11 +305,18 @@ class SQLAlchemyGenerator(BaseGenerator):
         }
         schema_classes: set[str] = set(table_by_class) | set(enum_by_class)
 
+        # ORM table class names in this file: those with an explicit __tablename__.
+        # Only these are auto-removed when absent from the schema; mixins, base
+        # classes, and helper classes (no __tablename__) are always left untouched.
+        orm_class_names: set[str] = set(tablename_to_class.values())
+
         replacements: list[tuple[int, int, list[str]]] = []
         for cls_name, (start, end) in existing_classes.items():
             if cls_name not in schema_classes:
-                # Leave untouched — destructive removal requires explicit
-                # confirmation at the CLI/MCP layer, not inside the generator.
+                # If the class is an ORM table (has __tablename__) and its table
+                # was deleted from the schema, remove it from the file.
+                if cls_name in orm_class_names:
+                    replacements.append((start, end, []))
                 continue
             if cls_name in table_by_class:
                 # Surgical update: only include non-inherited columns

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/generators/sqlmodel.py

@@ -78,12 +78,10 @@ def _field_args(col: Column, enum_names: set[str]) -> str:
         args.append("default_factory=lambda: datetime.now(timezone.utc)")
     elif col.default == "now":
         args.append("default_factory=datetime.now")
-    elif col.default == "list":
+    elif col.default in ("list", "[]"):
         args.append("default_factory=list")
-    elif col.default == "{}":
+    elif col.default in ("dict", "{}"):
         args.append("default_factory=dict")
-    elif col.default == "[]":
-        args.append("default_factory=list")
     elif col.default is not None:
         raw = col.default
         if raw == "true":
@@ -285,12 +283,18 @@ class SQLModelGenerator(BaseGenerator):
         schema_classes: set[str] = set(table_by_class) | set(enum_by_class)
 
         # Build replacements: (start, end, patched_lines) — applied bottom-up
+        # ORM table class names in this file: those with an explicit __tablename__.
+        # Only these are auto-removed when absent from the schema; mixins, base
+        # classes, and helper classes (no __tablename__) are always left untouched.
+        orm_class_names: set[str] = set(tablename_to_class.values())
+
         replacements: list[tuple[int, int, list[str]]] = []
         for cls_name, (start, end) in existing_classes.items():
             if cls_name not in schema_classes:
-                # Class exists in file but not in schema.
-                # Leave it untouched — destructive removal requires explicit
-                # confirmation at the CLI/MCP layer, not inside the generator.
+                # If the class is an ORM table (has __tablename__) and its table
+                # was deleted from the schema, remove it from the file.
+                if cls_name in orm_class_names:
+                    replacements.append((start, end, []))
                 continue
             if cls_name in table_by_class:
                 # Surgical update: preserve docstrings, Relationship lines,

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/importers/database.py

@@ -61,6 +61,7 @@ _PG_TYPE_MAP: dict[str, str] = {
 def import_from_database(
     connection_string: str,
     schema: str = "public",
+    orm: str = "sqlmodel",
 ) -> AlterSchema:
     """Introspect a live PostgreSQL database and return an ``AlterSchema``.
 
@@ -78,6 +79,10 @@ def import_from_database(
             have ``schema_name`` set on the resulting ``Table`` objects so
             that generated SQL uses the fully-qualified ``schema.table``
             reference.
+        orm: ORM backend to stamp on the returned ``AlterSchema`` —
+            ``"sqlmodel"`` (default) or ``"sqlalchemy"``.  Callers should
+            pass the current project's ORM so that ``alter apply`` generates
+            code in the correct style.
 
     Returns:
         An ``AlterSchema`` with grid-positioned tables and relations.
@@ -103,7 +108,7 @@ def import_from_database(
         ) from exc
 
     try:
-        return _introspect(conn, schema=schema)
+        return _introspect(conn, schema=schema, orm=orm)
     finally:
         conn.close()
 
@@ -113,7 +118,7 @@ def import_from_database(
 # ---------------------------------------------------------------------------
 
 
-def _introspect(conn: object, schema: str = "public") -> AlterSchema:
+def _introspect(conn: object, schema: str = "public", orm: str = "sqlmodel") -> AlterSchema:
     """Run all introspection queries and build the schema.
 
     Args:
@@ -181,6 +186,14 @@ def _introspect(conn: object, schema: str = "public") -> AlterSchema:
     uq_cols: set[tuple[str, str]] = {(r[0], r[1]) for r in cursor.fetchall()}
 
     # ── Foreign keys ─────────────────────────────────────────────────────────
+    # Only single-column FK constraints are fetched.  Joining kcu (the
+    # referencing side) with ccu (the referenced side) on constraint_name alone
+    # produces a cartesian product for composite FKs — e.g. a two-column FK
+    # (a, b) REFERENCES t(x, y) would yield four rows (a→x, a→y, b→x, b→y)
+    # instead of two.  Since alter's data model stores FK references per column
+    # (Column.foreign_key is a single string), composite FK constraints cannot
+    # be represented accurately regardless; the subquery below skips them
+    # entirely to avoid producing wrong per-column mappings.
     cursor.execute(
         """
         SELECT tc.table_name, kcu.column_name,
@@ -198,6 +211,12 @@ def _introspect(conn: object, schema: str = "public") -> AlterSchema:
           ON tc.constraint_name  = rc.constraint_name
         WHERE tc.table_schema   = %s
           AND tc.constraint_type = 'FOREIGN KEY'
+          AND (
+              SELECT count(*)
+              FROM information_schema.key_column_usage k2
+              WHERE k2.constraint_name = tc.constraint_name
+                AND k2.table_schema    = tc.table_schema
+          ) = 1
         ORDER BY tc.table_name, kcu.column_name
         """,
         (schema,),
@@ -281,7 +300,7 @@ def _introspect(conn: object, schema: str = "public") -> AlterSchema:
             )
         )
 
-    schema = AlterSchema(orm="sqlmodel", tables=tables, relations=relations)
+    schema = AlterSchema(orm=orm, tables=tables, relations=relations)
     _auto_position(schema)
     return schema
 

{alterdb-0.2.0 → alterdb-0.2.2}/src/alter/importers/sql.py

@@ -297,7 +297,14 @@ _CONSTRAINT_SPLIT_RE = re.compile(
 )
 
 _DEFAULT_RE = re.compile(
-    r"DEFAULT\s+('(?:[^']|'')*'|\S+)",
+    r"DEFAULT\s+"
+    r"("
+    r"'(?:[^']|'')*'"               # single-quoted string (handles '' escapes)
+    r"|"
+    r"\((?:[^()]*|\([^()]*\))*\)"   # parenthesized expression, one level of nesting
+    r"|"
+    r"\S+"                          # simple non-whitespace token
+    r")",
     re.IGNORECASE,
 )
 
@@ -353,12 +360,15 @@ def _parse_column_def(
     unique = "UNIQUE" in rest_upper
 
     # DEFAULT value
+    # Search `defn` (the original full column definition text) rather than the
+    # processed `rest`.  _COL_DEF_RE's optional size group `(?:\s*\(([^)]*)\))?`
+    # can accidentally consume a parenthesised DEFAULT expression such as
+    # `DEFAULT (1 + 2)`, stripping the parens before `rest` is assembled.
+    # Searching the raw `defn` bypasses that mangling.
     default: str | None = None
-    dm = _DEFAULT_RE.search(rest)
+    dm = _DEFAULT_RE.search(defn)
     if dm:
         raw_default = dm.group(1).strip()
-        # Normalise common defaults.  Strip trailing "()" before comparison
-        # because the regex may have consumed the parens as the "size" group.
         raw_upper_bare = raw_default.upper().rstrip("()")
         if raw_upper_bare in ("NOW", "CURRENT_TIMESTAMP"):
             default = "utcnow"