fixup! wip: simplify upgrade

Author: yankinmax

fs_storage/migrations/19.0.1.1.2/pre-migration.py

@@ -9,69 +9,127 @@
 
 
 def _get_server_env_mixin_fnames(cr, model: str) -> set[str]:
+    """Return the core mixin field names present on the model."""
     possible_fnames = ("server_env_defaults", "tech_name")
     cr.execute(
         SQL(
             """
             SELECT name
             FROM ir_model_fields
             WHERE model = %(model)s
-            AND name IN %(possible_fnames)s
+              AND name IN %(possible_fnames)s
             """,
             model=model,
             possible_fnames=possible_fnames,
         )
     )
-    return set(row[0] for row in cr.fetchall())
+    return {row[0] for row in cr.fetchall()}
 
 
-def _get_server_env_mixin_magic_fnames(cr, model: str) -> set[str]:
-    """Find all the magic server environment field names for a given model"""
-    # Get all fields created on-the-fly by the mixin. Following the name patterns:
-    # - default fields: x_<field_name>_env_default
-    # - is editable fields: x_<field_name>_env_is_editable
+def _get_server_env_mixin_magic_fnames(cr, model):
+    """Return the dynamic server_environment helper fields for the model.
+
+    These are the fields created on the fly by server.env.mixin:
+    - x_<field_name>_env_default
+    - x_<field_name>_env_is_editable
+    """
     cr.execute(
         SQL(
             """
             SELECT name
             FROM ir_model_fields
             WHERE model = %(model)s
-            AND name LIKE 'x_%%_env_default'
-            OR name LIKE 'x_%%_env_is_editable'
+              AND (
+                    name LIKE 'x_%%_env_default'
+                 OR name LIKE 'x_%%_env_is_editable'
+              )
             """,
             model=model,
         )
     )
-    return set(row[0] for row in cr.fetchall())
+    return {row[0] for row in cr.fetchall()}
+
+
+def _get_existing_columns(cr, table_name):
+    """Return the current physical columns of a PostgreSQL table."""
+    cr.execute(
+        SQL(
+            """
+            SELECT column_name
+            FROM information_schema.columns
+            WHERE table_schema = 'public'
+              AND table_name = %(table_name)s
+            ORDER BY ordinal_position
+            """,
+            table_name=table_name,
+        )
+    )
+    return [row[0] for row in cr.fetchall()]
 
 
 def migrate(cr, version):
+    """Move XMLIDs to the glue module and snapshot the original schema.
+
+    This keeps the server_environment ir.model.fields metadata attached to the
+    new module and preserves field values.
+    In the end, the original fs_storage schema is preserved at post cleanup.
+    """
+
     if not version:
         return
+
     model = "fs.storage"
+    old_module = "fs_storage"
+    new_module = "fs_storage_environment"
+
     mixin_fnames = _get_server_env_mixin_fnames(cr, model)
     magic_fnames = _get_server_env_mixin_magic_fnames(cr, model)
     to_move_fnames = mixin_fnames | magic_fnames
-    old_module = "fs_storage"
-    new_module = "fs_storage_environment"
+
     rename_specs = [
         (field_xmlid(old_module, model, fname), field_xmlid(new_module, model, fname))
         for fname in to_move_fnames
     ]
     openupgrade.rename_xmlids(cr, rename_specs, allow_merge=True)
+
     # Add noupdate to the magic_fnames, to prevent Odoo from deleting them in upgrade
+    if magic_fnames:
+        openupgrade.logged_query(
+            cr,
+            """
+            UPDATE ir_model_data SET noupdate = TRUE
+            WHERE module = %(module)s
+            AND name IN %(names)s
+            """,
+            dict(
+                module=new_module,
+                names=tuple(
+                    field_xmlid(new_module, model, fname).split(".")[1]
+                    for fname in magic_fnames
+                ),
+            ),
+        )
+
+    # Snapshot the original physical schema.
+    # Post cleanup hook in `fs_storage_environment` will compare
+    # the final table with this snapshot and drop every created extra column.
+    original_columns = _get_existing_columns(cr, "fs_storage")
     openupgrade.logged_query(
         cr,
         """
-        UPDATE ir_model_data SET noupdate = TRUE
-        WHERE module = %(module)s
-        AND name IN %(names)s
+        CREATE TABLE IF NOT EXISTS fs_storage_original_columns (
+            column_name varchar PRIMARY KEY
+        )
         """,
-        dict(
-            module=new_module,
-            names=tuple(
-                field_xmlid(new_module, model, fname).split(".")[1]
-                for fname in magic_fnames
-            ),
-        ),
     )
+    openupgrade.logged_query(cr, "DELETE FROM fs_storage_original_columns")
+
+    for column_name in original_columns:
+        cr.execute(
+            """
+            INSERT INTO fs_storage_original_columns (column_name)
+            VALUES (%s)
+            ON CONFLICT (column_name) DO NOTHING
+            """,
+            (column_name,),
+        )

fs_storage_environment/__init__.py

@@ -1 +1,2 @@
 from . import models
+from .hooks import post_init_hook

fs_storage_environment/__manifest__.py

@@ -13,4 +13,5 @@
     "development_status": "Beta",
     "depends": ["fs_storage", "server_environment"],
     "auto_install": True,
+    "post_init_hook": "post_init_hook",
 }

fs_storage_environment/hooks.py

@@ -0,0 +1,61 @@
+# Copyright 2026 Camptocamp SA
+# License AGPL-3.0 or later (http://www.gnu.org/licenses/agpl.html)
+
+import logging
+
+from openupgradelib import openupgrade
+
+_logger = logging.getLogger(__name__)
+
+# This post_init_hook is needed as a part of migration for those environments
+# which had originally `fs_storage` installed with `server_environment` dependency.
+# When migration is performed, `fs_storage` is being upgraded
+# and `server.env.mixin` is not yet applied, the server env fields
+# coming from `fs.storage` and the inheriting models are created as regular fields,
+# so new database columns are created for them, which we don't want.
+
+
+def _get_table_columns(cr, table_name):
+    """Return the current physical columns of a PostgreSQL table."""
+    cr.execute(
+        """
+        SELECT column_name
+          FROM information_schema.columns
+         WHERE table_schema = 'public'
+           AND table_name = %s
+         ORDER BY ordinal_position
+        """,
+        (table_name,),
+    )
+    return [row[0] for row in cr.fetchall()]
+
+
+def post_init_hook(env):
+    """Restore the original fs_storage schema by column diff."""
+    cr = env.cr
+
+    if not openupgrade.table_exists(cr, "fs_storage_original_columns"):
+        _logger.info(
+            """
+                Original columns snapshot table not found.
+                Skipping fs_storage schema restoration as it is likely not needed.
+            """
+        )
+        return
+
+    cr.execute("SELECT column_name FROM fs_storage_original_columns")
+    original_columns = {row[0] for row in cr.fetchall()}
+    current_columns = set(_get_table_columns(cr, "fs_storage"))
+    columns_to_drop = sorted(current_columns - original_columns)
+
+    for column_name in columns_to_drop:
+        if openupgrade.column_exists(cr, "fs_storage", column_name):
+            openupgrade.logged_query(
+                cr,
+                f'ALTER TABLE fs_storage DROP COLUMN "{column_name}"',
+            )
+
+    _logger.info("Dropped extra fs_storage columns: %s", columns_to_drop)
+
+    if openupgrade.table_exists(cr, "fs_storage_original_columns"):
+        openupgrade.logged_query(cr, "DROP TABLE fs_storage_original_columns")