half-orm-dev 0.17.3a8__py3-none-any.whl → 0.17.3a9__py3-none-any.whl

half_orm_dev/migrations/0/17/4/00_toml_dict_format.py

@@ -0,0 +1,204 @@
+"""
+Migration: Convert TOML patches to dict format with merge_commit.
+
+This migration converts the old TOML format:
+    [patches]
+    "1-auth" = "staged"
+    "2-api" = "candidate"
+
+To the new dict format:
+    [patches]
+    "1-auth" = { status = "staged", merge_commit = "abc123de" }
+    "2-api" = { status = "candidate" }
+
+For staged patches, the merge_commit hash is retrieved from git history.
+"""
+
+from pathlib import Path
+import subprocess
+import sys
+
+try:
+    import tomli
+except ImportError:
+    import tomllib as tomli
+
+try:
+    import tomli_w
+except ImportError:
+    raise ImportError(
+        "tomli_w is required for this migration. "
+        "Install it with: pip install tomli_w"
+    )
+
+
+def get_description():
+    """Return migration description."""
+    return "Convert TOML patches to dict format with merge_commit"
+
+
+def find_merge_commit(repo, patch_id: str, version: str) -> str:
+    """
+    Find the merge commit hash for a staged patch.
+
+    Searches git history for the commit that merged the patch branch
+    into the release branch.
+
+    Args:
+        repo: Repo instance
+        patch_id: Patch identifier (e.g., "456-user-auth")
+        version: Release version (e.g., "0.17.0")
+
+    Returns:
+        Commit hash (8 characters) or empty string if not found
+    """
+    release_branch = f"ho-release/{version}"
+
+    try:
+        # Search for merge commit message pattern
+        # Pattern: [HOP] Merge #PATCH_ID into %"VERSION"
+        result = subprocess.run(
+            ['git', 'log', '--all', '--grep', f'Merge #{patch_id}',
+             '--format=%H', '-n', '1'],
+            cwd=repo.base_dir,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        commit_hash = result.stdout.strip()
+        if commit_hash:
+            return commit_hash[:8]
+
+        # Fallback: search for the move to stage commit
+        # Pattern: [HOP] move patch #PATCH_ID from candidate to stage
+        result = subprocess.run(
+            ['git', 'log', '--all', '--grep', f'move patch #{patch_id}',
+             '--format=%H', '-n', '1'],
+            cwd=repo.base_dir,
+            capture_output=True,
+            text=True,
+            check=True
+        )
+
+        commit_hash = result.stdout.strip()
+        if commit_hash:
+            # Get the parent commit (the merge commit is the one before the move)
+            result = subprocess.run(
+                ['git', 'rev-parse', f'{commit_hash}^'],
+                cwd=repo.base_dir,
+                capture_output=True,
+                text=True,
+                check=True
+            )
+            parent_hash = result.stdout.strip()
+            if parent_hash:
+                return parent_hash[:8]
+
+    except subprocess.CalledProcessError:
+        pass
+
+    return ""
+
+
+def migrate(repo):
+    """
+    Execute migration: Convert TOML patches to dict format.
+
+    For each X.Y.Z-patches.toml file:
+    1. Read current content
+    2. Check if already in dict format
+    3. Convert to dict format:
+       - candidates: { status = "candidate" }
+       - staged: { status = "staged", merge_commit = "..." }
+    4. Find merge_commit from git history for staged patches
+    5. Write updated TOML file
+
+    Args:
+        repo: Repo instance
+    """
+    print("Migrating TOML patches to dict format with merge_commit...")
+
+    releases_dir = Path(repo.releases_dir)
+    if not releases_dir.exists():
+        print("  No releases directory found, skipping migration.")
+        return
+
+    # Find all TOML patches files
+    toml_files = list(releases_dir.glob("*-patches.toml"))
+
+    if not toml_files:
+        print("  No TOML patches files found, skipping migration.")
+        return
+
+    migrated_count = 0
+
+    for toml_file in toml_files:
+        # Extract version from filename
+        version = toml_file.stem.replace('-patches', '')
+
+        print(f"  Processing {version}...")
+
+        try:
+            # Read current TOML content
+            with toml_file.open('rb') as f:
+                data = tomli.load(f)
+
+            patches = data.get("patches", {})
+
+            if not patches:
+                print(f"    No patches in {version}, skipping")
+                continue
+
+            # Check if already in dict format
+            first_value = next(iter(patches.values()))
+            if isinstance(first_value, dict):
+                print(f"    Already in dict format, skipping")
+                continue
+
+            # Convert to dict format
+            new_patches = {}
+            staged_without_commit = []
+
+            for patch_id, status in patches.items():
+                if status == "candidate":
+                    new_patches[patch_id] = {"status": "candidate"}
+                elif status == "staged":
+                    # Find merge commit from git history
+                    merge_commit = find_merge_commit(repo, patch_id, version)
+                    if merge_commit:
+                        new_patches[patch_id] = {
+                            "status": "staged",
+                            "merge_commit": merge_commit
+                        }
+                    else:
+                        # No merge_commit found, store without it
+                        new_patches[patch_id] = {"status": "staged"}
+                        staged_without_commit.append(patch_id)
+                else:
+                    # Unknown status, preserve as-is in dict format
+                    new_patches[patch_id] = {"status": status}
+
+            # Update data and write
+            data["patches"] = new_patches
+
+            with toml_file.open('wb') as f:
+                tomli_w.dump(data, f)
+
+            print(f"    Converted {len(patches)} patch(es)")
+            if staged_without_commit:
+                print(f"    Warning: No merge_commit found for: {', '.join(staged_without_commit)}",
+                      file=sys.stderr)
+
+            migrated_count += 1
+
+        except Exception as e:
+            print(f"  Error processing {version}: {e}", file=sys.stderr)
+            continue
+
+    repo.hgit.add('.hop')
+
+    if migrated_count > 0:
+        print(f"\nMigration complete: {migrated_count} file(s) converted to dict format")
+    else:
+        print("\nNo files needed migration")

half_orm_dev/patch_manager.py

@@ -488,61 +488,84 @@ class PatchManager:
         Apply patch with full release context.
 
         Workflow:
-        1. Restore DB from production baseline (model/schema.sql)
-        2. Apply all release patches in order (RC1, RC2, ..., stage)
-        3. If current patch is in release, apply it in correct order
-        4. If current patch is NOT in release, apply it at the end
-        5. Generate Python code
+        1. Restore DB from release schema (includes all staged patches)
+        2. Apply only the current patch
+        3. Generate Python code
 
-        Examples:
-            # Release context: [123, 456, 789, 234]
-            # Current patch: 789 (already in release)
+        If release schema doesn't exist (backward compatibility), falls back to:
+        1. Restore DB from production baseline
+        2. Apply all staged patches in order
+        3. Apply current patch
+        4. Generate Python code
 
-            apply_patch_complete_workflow("789")
+        Examples:
+            # With release schema (new workflow):
+            apply_patch_complete_workflow("999")
             # Execution:
-            # 1. Restore DB (1.3.5)
-            # 2. Apply 123
-            # 3. Apply 456
-            # 4. Apply 789 ← In correct order
-            # 5. Apply 234
-            # 6. Generate code
-
-            # Current patch: 999 (NOT in release)
+            # 1. Restore DB from release-0.17.1.sql (includes staged patches)
+            # 2. Apply 999
+            # 3. Generate code
+
+            # Without release schema (backward compat):
             apply_patch_complete_workflow("999")
             # Execution:
-            # 1. Restore DB (1.3.5)
-            # 2. Apply 123
-            # 3. Apply 456
-            # 4. Apply 789
-            # 5. Apply 234
-            # 6. Apply 999 ← At the end
-            # 7. Generate code
+            # 1. Restore DB from schema.sql (prod)
+            # 2. Apply all staged patches
+            # 3. Apply 999
+            # 4. Generate code
         """
 
         try:
-            # Étape 1: Restauration DB
-            self._repo.restore_database_from_schema()
-
-            # Étape 2: Récupérer contexte release complet
-            release_patches = self._repo.release_manager.get_all_release_context_patches()
+            # Get release version for this patch
+            version = self._find_version_for_candidate(patch_id)
+            if not version:
+                # Try to find from staged patches
+                version = self._repo.release_manager.get_next_release_version()
 
             applied_release_files = []
             applied_current_files = []
             patch_was_in_release = False
 
-            # Étape 3: Appliquer patches
-            for patch in release_patches:
-                if patch == patch_id:
-                    patch_was_in_release = True
-                files = self.apply_patch_files(patch, self._repo.model)
-                applied_release_files.extend(files)
+            # Check if release schema exists
+            release_schema_path = None
+            if version:
+                release_schema_path = self._repo.get_release_schema_path(version)
+
+            if release_schema_path and release_schema_path.exists():
+                # New workflow: restore from release schema (includes all staged patches)
+                self._repo.restore_database_from_release_schema(version)
 
-            # Étape 4: Si patch courant pas dans release, l'appliquer maintenant
-            if not patch_was_in_release:
+                # Apply only the current patch
                 files = self.apply_patch_files(patch_id, self._repo.model)
                 applied_current_files = files
+            else:
+                # Backward compatibility: old workflow
+                # Also generates release schema for migration of existing projects
+                self._repo.restore_database_from_schema()
 
-            # Étape 5: Génération code Python
+                # Get and apply all staged release patches
+                release_patches = self._repo.release_manager.get_all_release_context_patches()
+
+                for patch in release_patches:
+                    if patch == patch_id:
+                        patch_was_in_release = True
+                    files = self.apply_patch_files(patch, self._repo.model)
+                    applied_release_files.extend(files)
+
+                # Generate release schema for existing projects migration
+                # This captures the state after all staged patches are applied
+                if version:
+                    try:
+                        self._repo.generate_release_schema(version)
+                    except Exception:
+                        pass  # Non-critical, continue with apply
+
+                # If current patch not in release (candidate), apply it now
+                if not patch_was_in_release:
+                    files = self.apply_patch_files(patch_id, self._repo.model)
+                    applied_current_files = files
+
+            # Generate Python code
             # Track generated files
             package_dir = Path(self._base_dir) / self._repo_name
             files_before = set()
@@ -557,14 +580,14 @@ class PatchManager:
 
             generated_files = [str(f.relative_to(self._base_dir)) for f in files_after]
 
-            # Étape 6: Retour succès
+            # Return success
             return {
                 'patch_id': patch_id,
-                'release_patches': [p for p in release_patches if p != patch_id],
                 'applied_release_files': applied_release_files,
                 'applied_current_files': applied_current_files,
                 'patch_was_in_release': patch_was_in_release,
                 'generated_files': generated_files,
+                'used_release_schema': release_schema_path is not None and release_schema_path.exists(),
                 'status': 'success',
                 'error': None
             }
@@ -619,9 +642,11 @@ class PatchManager:
         # Apply files in lexicographic order
         for patch_file in structure.files:
             if patch_file.is_sql:
+                print('XXX', patch_file.name)
                 self._execute_sql_file(patch_file.path, database_model)
                 applied_files.append(patch_file.name)
             elif patch_file.is_python:
+                print('XXX', patch_file.name)
                 self._execute_python_file(patch_file.path)
                 applied_files.append(patch_file.name)
             # Other file types are ignored (not executed)
@@ -1909,8 +1934,17 @@ class PatchManager:
                 f"You may need to resolve conflicts manually."
             )
 
-        # 6. Move from candidates to stage
-        self._move_patch_to_stage(patch_id, version)
+        # 5b. Get merge commit hash
+        merge_commit = self._repo.hgit.last_commit()
+
+        # 6. Move from candidates to stage (with merge commit hash)
+        self._move_patch_to_stage(patch_id, version, merge_commit)
+
+        # 6b. Regenerate release schema (DB is already in correct state after validation)
+        try:
+            self._update_release_schemas(version)
+        except Exception as e:
+            raise PatchManagerError(f"Failed to update release schema: {e}")
 
         # 7. Commit changes on release branch (TOML file is in .hop/releases/)
         # This also syncs .hop/ to all active branches automatically via decorator
@@ -1921,6 +1955,9 @@ class PatchManager:
         except Exception as e:
             raise PatchManagerError(f"Failed to commit/push changes: {e}")
 
+        # 7b. Propagate release schema to higher version releases (now that commit is done)
+        self._propagate_release_schema_to_higher_versions(version)
+
         # 8. Delete patch branch (local and remote)
         try:
             self._repo.hgit.delete_local_branch(patch_branch)
@@ -1936,6 +1973,129 @@ class PatchManager:
             'merged_into': release_branch
         }
 
+    def _update_release_schemas(self, version: str) -> None:
+        """
+        Update release schema for current version and propagate to higher versions.
+
+        After a patch is merged, regenerates the release schema file for the
+        current version and updates all higher version releases that depend on it.
+
+        Args:
+            version: Current release version (e.g., "0.17.1")
+
+        Workflow:
+        1. Add release schema to staging (already generated during validation)
+        2. Find all release branches with higher versions
+        3. For each higher version:
+           - Checkout to that branch
+           - Restore DB from current release schema
+           - Apply all staged patches for that release
+           - Regenerate its release schema
+           - Commit the updated schema
+        4. Return to original branch
+        """
+        from packaging.version import Version
+        from half_orm_dev.release_file import ReleaseFile
+
+        original_branch = self._repo.hgit.branch
+        current_ver = Version(version)
+
+        # 1. Write and add release schema to staging area (if not hotfix mode)
+        # Schema content was saved during validation with correct DB state
+        release_schema_path = self._repo.get_release_schema_path(version)
+        if hasattr(self, '_pending_release_schema_content') and self._pending_release_schema_content:
+            click.echo(f"  • Writing release schema ({len(self._pending_release_schema_content)} bytes)")
+            release_schema_path.write_text(self._pending_release_schema_content, encoding='utf-8')
+            self._pending_release_schema_content = None  # Clear after use
+            self._repo.hgit.add(str(release_schema_path))
+        else:
+            # Hotfix mode or no content - skip release schema
+            click.echo(f"  • Skipping release schema (hotfix mode)")
+
+        # NOTE: Do NOT checkout other branches here!
+        # The commit will be done later by commit_and_sync_to_active_branches()
+        # Propagation to higher releases is disabled for now as it causes issues
+        # with uncommitted changes being lost during checkout.
+        # TODO: Re-enable propagation after the main commit is done.
+
+        # 2. Find higher version releases (disabled - propagation moved to after commit)
+        releases_dir = Path(self._repo.releases_dir)
+        higher_releases = []
+
+        for toml_file in releases_dir.glob("*-patches.toml"):
+            rel_version = toml_file.stem.replace('-patches', '')
+            try:
+                rel_ver = Version(rel_version)
+                if rel_ver > current_ver:
+                    higher_releases.append(rel_version)
+            except Exception:
+                continue
+
+        # Sort by version (ascending)
+        higher_releases.sort(key=lambda v: Version(v))
+
+        # Store higher releases for later propagation (after commit)
+        # This avoids losing uncommitted changes when checking out other branches
+        self._pending_higher_releases = higher_releases if higher_releases else None
+
+    def _propagate_release_schema_to_higher_versions(self, version: str) -> None:
+        """
+        Propagate release schema changes to higher version releases.
+
+        Called after commit to update release schemas for all releases
+        with version > current version.
+
+        Args:
+            version: Current release version that was just updated
+        """
+        from packaging.version import Version
+        from half_orm_dev.release_file import ReleaseFile
+
+        if not hasattr(self, '_pending_higher_releases') or not self._pending_higher_releases:
+            return
+
+        higher_releases = self._pending_higher_releases
+        self._pending_higher_releases = None  # Clear after use
+
+        original_branch = self._repo.hgit.branch
+        releases_dir = Path(self._repo.releases_dir)
+
+        for higher_version in higher_releases:
+            higher_branch = f"ho-release/{higher_version}"
+
+            if not self._repo.hgit.branch_exists(higher_branch):
+                continue
+
+            click.echo(f"  • Propagating to {higher_branch}...")
+
+            try:
+                # Checkout to higher version branch
+                self._repo.hgit.checkout(higher_branch)
+
+                # Restore DB from current release schema (which includes the new patch)
+                self._repo.restore_database_from_release_schema(version)
+
+                # Apply all staged patches for this higher release
+                release_file = ReleaseFile(higher_version, releases_dir)
+                if release_file.exists():
+                    staged_patches = release_file.get_patches(status="staged")
+                    for pid in staged_patches:
+                        patch_dir = Path(self._base_dir) / "Patches" / pid
+                        if patch_dir.exists():
+                            self.apply_patch_files(pid, self._repo.model)
+
+                # Regenerate release schema for this higher version
+                higher_schema_path = self._repo.generate_release_schema(higher_version)
+                self._repo.hgit.add(str(higher_schema_path))
+                self._repo.hgit.commit('-m', f"[HOP] Update release schema from %{version}")
+                self._repo.hgit.push()
+
+            except Exception as e:
+                click.echo(f"    ⚠️  Warning: Failed to propagate to {higher_branch}: {e}")
+
+        # Return to original branch
+        self._repo.hgit.checkout(original_branch)
+
     def _validate_patch_before_merge(
         self,
         patch_id: str,
@@ -1976,6 +2136,8 @@ class PatchManager:
         # Save current branch
         original_branch = self._repo.hgit.branch
         temp_branch = f"ho-validate/{patch_id}"
+        release_schema_content = None
+        release_schema_path = None
 
         try:
             click.echo(f"\n🔍 Validating patch {utils.Color.bold(patch_id)} before merge...")
@@ -1998,24 +2160,36 @@ class PatchManager:
             # 3. Run patch apply and verify no modifications
             click.echo(f"  • Running patch apply to verify idempotency...")
             try:
-                # Get list of staged patches for this version from TOML file
-                release_file = ReleaseFile(version, Path(self._repo.releases_dir))
-                staged_patches = []
-                if release_file.exists():
-                    staged_patches = release_file.get_patches(status="staged")
+                # Check if release schema exists
+                release_schema_path = self._repo.get_release_schema_path(version)
 
-                # Apply all staged patches + current patch
-                all_patches = staged_patches + [patch_id]
+                if release_schema_path.exists():
+                    # New workflow: restore from release schema (includes all staged patches)
+                    self._repo.restore_database_from_release_schema(version)
 
-                # Restore database and apply patches
-                self._repo.restore_database_from_schema()
-
-                for pid in all_patches:
-                    patch_dir = Path(self._repo.base_dir) / "Patches" / pid
+                    # Apply only the current patch
+                    patch_dir = Path(self._repo.base_dir) / "Patches" / patch_id
                     if patch_dir.exists():
-                        self.apply_patch_files(pid, self._repo.model)
+                        self.apply_patch_files(patch_id, self._repo.model)
+                else:
+                    # Fallback: old workflow for backward compatibility
+                    release_file = ReleaseFile(version, Path(self._repo.releases_dir))
+                    staged_patches = []
+                    if release_file.exists():
+                        staged_patches = release_file.get_patches(status="staged")
+
+                    # Apply all staged patches + current patch
+                    all_patches = staged_patches + [patch_id]
+
+                    # Restore database and apply patches
+                    self._repo.restore_database_from_schema()
 
-                # Generate modules                
+                    for pid in all_patches:
+                        patch_dir = Path(self._repo.base_dir) / "Patches" / pid
+                        if patch_dir.exists():
+                            self.apply_patch_files(pid, self._repo.model)
+
+                # Generate modules
                 modules.generate(self._repo)
 
                 # Check if any files were modified
@@ -2043,10 +2217,33 @@ class PatchManager:
             # 4. Run tests (best-effort)
             self._run_tests_if_available()
 
+            # 5. Generate release schema while DB is in correct state
+            # This captures prod + all staged patches + current patch
+            # Skip for hotfix releases (detected by presence of X.Y.Z.txt production file)
+            prod_file = Path(self._repo.releases_dir) / f"{version}.txt"
+            is_hotfix = prod_file.exists()
+
+            if is_hotfix:
+                click.echo(f"  • Skipping release schema (hotfix mode)")
+                release_schema_content = None
+            else:
+                click.echo(f"  • Generating release schema...")
+                release_schema_path = self._repo.generate_release_schema(version)
+
+                # Save schema content to restore after branch checkout
+                # (the file will be lost when switching branches)
+                release_schema_content = release_schema_path.read_text(encoding='utf-8')
+
+                # Delete the file to avoid checkout conflicts
+                # (content is saved in memory and will be written after checkout)
+                release_schema_path.unlink()
+
+                click.echo(f"  • {utils.Color.green('✓')} Release schema generated")
+
             click.echo(f"  • {utils.Color.green('✓')} Validation passed!\n")
 
         finally:
-            # 5. Cleanup: Delete temp branch and return to original branch
+            # 6. Cleanup: Delete temp branch and return to original branch
             try:
                 # Return to original branch
                 if self._repo.hgit.branch != original_branch:
@@ -2059,6 +2256,10 @@ class PatchManager:
                 # Cleanup errors are non-critical, just warn
                 click.echo(f"⚠️  Warning: Failed to cleanup temp branch {temp_branch}: {e}")
 
+        # Store release schema content for later use in _update_release_schemas
+        # (after merge, when we're on the release branch)
+        self._pending_release_schema_content = release_schema_content
+
     def _run_tests_if_available(self) -> None:
         """
         Run tests if test configuration is available.
@@ -2631,7 +2832,7 @@ class PatchManager:
 
         return '\n'.join(lines)
 
-    def _move_patch_to_stage(self, patch_id: str, version: str) -> None:
+    def _move_patch_to_stage(self, patch_id: str, version: str, merge_commit: str) -> None:
         """
         Move patch from candidate to staged status.
 
@@ -2641,19 +2842,21 @@ class PatchManager:
         Args:
             patch_id: Patch identifier to move
             version: Release version
+            merge_commit: Git commit hash of the merge commit
 
         Raises:
             PatchManagerError: If operation fails
 
         Examples:
-            self._move_patch_to_stage("456-user-auth", "0.17.0")
-            # Changes "456-user-auth" = "candidate" to "456-user-auth" = "staged"
+            self._move_patch_to_stage("456-user-auth", "0.17.0", "abc123de")
+            # Changes "456-user-auth" = {status = "candidate"}
+            # to "456-user-auth" = {status = "staged", merge_commit = "abc123de"}
             # Order is preserved!
         """
         release_file = ReleaseFile(version, self._releases_dir)
 
         try:
-            release_file.move_to_staged(patch_id)
+            release_file.move_to_staged(patch_id, merge_commit)
 
             # Stage file for commit
             self._repo.hgit.add(str(release_file.file_path))

half_orm_dev/release_file.py

@@ -38,8 +38,8 @@ class ReleaseFile:
 
     File format:
         [patches]
-        "1-auth" = "candidate"
-        "2-api" = "staged"
+        "1-auth" = { status = "staged", merge_commit = "abc123def" }
+        "2-api" = { status = "candidate" }
 
     The order of patches in the file is preserved and represents the application order.
     """
@@ -144,7 +144,7 @@ class ReleaseFile:
 
         if before is None:
             # Add at end
-            patches[patch_id] = "candidate"
+            patches[patch_id] = {"status": "candidate"}
         else:
             # Insert before specified patch
             if before not in patches:
@@ -156,7 +156,7 @@ class ReleaseFile:
             new_patches = {}
             for key, value in patches.items():
                 if key == before:
-                    new_patches[patch_id] = "candidate"
+                    new_patches[patch_id] = {"status": "candidate"}
                 new_patches[key] = value
 
             patches = new_patches
@@ -164,7 +164,7 @@ class ReleaseFile:
         data["patches"] = patches
         self._write(data)
 
-    def move_to_staged(self, patch_id: str) -> None:
+    def move_to_staged(self, patch_id: str, merge_commit: str) -> None:
         """
         Change patch status from candidate to staged.
 
@@ -173,13 +173,15 @@ class ReleaseFile:
 
         Args:
             patch_id: Patch identifier to move
+            merge_commit: Git commit hash of the merge commit
 
         Raises:
             ReleaseFileError: If patch not found or operation fails
 
         Examples:
-            release_file.move_to_staged("1-auth")
-            # Changes "1-auth" = "candidate" to "1-auth" = "staged"
+            release_file.move_to_staged("1-auth", "abc123def")
+            # Changes "1-auth" = {status = "candidate"}
+            # to "1-auth" = {status = "staged", merge_commit = "abc123def"}
         """
         data = self._read()
         patches = data.get("patches", {})
@@ -189,12 +191,13 @@ class ReleaseFile:
                 f"Patch {patch_id} not found in {self.version}"
             )
 
-        if patches[patch_id] == "staged":
+        patch_data = patches[patch_id]
+        if patch_data.get("status") == "staged":
             raise ReleaseFileError(
                 f"Patch {patch_id} is already staged"
             )
 
-        patches[patch_id] = "staged"
+        patches[patch_id] = {"status": "staged", "merge_commit": merge_commit}
         data["patches"] = patches
         self._write(data)
 
@@ -225,8 +228,8 @@ class ReleaseFile:
             return list(patches.keys())
 
         return [
-            patch_id for patch_id, patch_status in patches.items()
-            if patch_status == status
+            patch_id for patch_id, patch_data in patches.items()
+            if patch_data.get("status") == status
         ]
 
     def get_patch_status(self, patch_id: str) -> Optional[str]:
@@ -246,7 +249,10 @@ class ReleaseFile:
         """
         data = self._read()
         patches = data.get("patches", {})
-        return patches.get(patch_id)
+        patch_data = patches.get(patch_id)
+        if patch_data is None:
+            return None
+        return patch_data.get("status")
 
     def remove_patch(self, patch_id: str) -> None:
         """
@@ -276,19 +282,27 @@ class ReleaseFile:
         """Check if release file exists."""
         return self.file_path.exists()
 
-    def get_all_patches_with_status(self) -> Dict[str, str]:
+    def get_merge_commit(self, patch_id: str) -> Optional[str]:
         """
-        Get all patches with their status.
+        Get merge commit hash of a staged patch.
+
+        Args:
+            patch_id: Patch identifier
 
         Returns:
-            Ordered dict of {patch_id: status}
+            Merge commit hash, or None if patch not found or not staged
 
         Examples:
-            patches = release_file.get_all_patches_with_status()
-            # → {"1-auth": "staged", "2-api": "candidate"}
+            commit = release_file.get_merge_commit("1-auth")
+            if commit:
+                print(f"Patch was merged in commit {commit}")
         """
         data = self._read()
-        return data.get("patches", {})
+        patches = data.get("patches", {})
+        patch_data = patches.get(patch_id)
+        if patch_data is None:
+            return None
+        return patch_data.get("merge_commit")
 
     def set_metadata(self, metadata: Dict) -> None:
         """

half_orm_dev/release_manager.py

@@ -680,6 +680,8 @@ class ReleaseManager:
         """
         Lit les patch IDs d'un fichier de release.
 
+        Format: patch_id:merge_commit (one per line)
+
         Ignore:
         - Lignes vides
         - Commentaires (#)
@@ -695,41 +697,107 @@ class ReleaseManager:
             for line in f:
                 line = line.strip()
                 if line and not line.startswith('#'):
-                    patch_ids.append(line)
+                    patch_id = line.split(':')[0]
+                    patch_ids.append(patch_id)
 
         return patch_ids
 
-    def _apply_release_patches(self, version: str, hotfix=False) -> None:
+    def read_release_patches_with_commits(self, filename: str) -> dict:
+        """
+        Lit les patch IDs et merge_commits d'un fichier de release.
+
+        Format: patch_id:merge_commit (one per line)
+
+        Returns:
+            dict: {patch_id: merge_commit}
+
+        Example:
+            # File content:
+            # 1-premier:ce96282f
+            # 2-second:8e10f11b
+            patches = read_release_patches_with_commits("0.1.0-rc1.txt")
+            # → {"1-premier": "ce96282f", "2-second": "8e10f11b"}
+        """
+        file_path = self._releases_dir / filename
+
+        if not file_path.exists():
+            return {}
+
+        patches = {}
+        with open(file_path, 'r', encoding='utf-8') as f:
+            for line in f:
+                line = line.strip()
+                if line and not line.startswith('#'):
+                    patch_id, merge_commit = line.split(':', 1)
+                    patches[patch_id] = merge_commit
+
+        return patches
+
+    def _apply_release_patches(self, version: str, hotfix=False, force_apply=False) -> None:
         """
         Apply all patches for a release version to the database.
 
-        Restores database from baseline and applies patches in order:
+        If a release schema exists (release-X.Y.Z.sql) and force_apply=False,
+        uses it directly. Otherwise, restores database from baseline and
+        applies patches in order:
         1. All RC patches (rc1, rc2, etc.)
         2. Stage patches
 
+        For staged patches with merge_commit recorded, checks out each commit
+        before applying the patch to ensure the correct Python code context.
+
         Args:
             version: Release version (e.g., "0.1.0")
+            hotfix: If True, skip RC patches (hotfix workflow)
+            force_apply: If True, always apply patches individually even if
+                        release schema exists (used for production validation)
 
         Raises:
             ReleaseManagerError: If patch application fails
         """
-        # Restore database from baseline
+        # Check if release schema exists (new workflow)
+        release_schema_path = self._repo.get_release_schema_path(version)
+        if release_schema_path.exists() and not force_apply:
+            # New workflow: restore from release schema (already contains all staged patches)
+            self._repo.restore_database_from_release_schema(version)
+            return
+
+        # Fallback: old workflow - restore database from baseline
         self._repo.restore_database_from_schema()
 
-        # Apply all RC patches in order
+        current_branch = self._repo.hgit.branch
+
+        # Collect patches already applied from RC files
+        applied_patches = set()
+
+        # Apply all RC patches in order (with merge_commit checkout)
         if not hotfix:
             rc_files = self._get_label_files(version, 'rc')
             for rc_file in rc_files:
-                rc_patches = self.read_release_patches(rc_file.name)
-                for patch_id in rc_patches:
+                rc_patches = self.read_release_patches_with_commits(rc_file.name)
+                for patch_id, merge_commit in rc_patches.items():
+                    if merge_commit:
+                        self._repo.hgit.checkout(merge_commit)
                     self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+                    applied_patches.add(patch_id)
 
-        # Apply staged patches from TOML file (if in development) or from snapshot (if released)
-        # Try TOML file first (development)
+        # Apply staged patches from TOML file that are NOT already in RC files
+        # (patches added after promote_to_rc)
         release_file = ReleaseFile(version, self._releases_dir)
         if release_file.exists():
             # Development: read from TOML
             stage_patches = release_file.get_patches(status="staged")
+
+            # Apply only patches not already applied from RC
+            for patch_id in stage_patches:
+                if patch_id in applied_patches:
+                    continue  # Already applied from RC file
+
+                merge_commit = release_file.get_merge_commit(patch_id)
+                if merge_commit:
+                    # Checkout the merge commit to have correct Python code
+                    self._repo.hgit.checkout(merge_commit)
+                self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
         else:
             # Production: read from hotfix snapshot if it exists
             # This handles the case where we're applying a hotfix release
@@ -741,8 +809,14 @@ class ReleaseManager:
                 # No patches to apply
                 stage_patches = []
 
-        for patch_id in stage_patches:
-            self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+            # For production snapshots (no TOML), apply patches without checkout
+            # (merge_commit info not available in .txt files)
+            for patch_id in stage_patches:
+                if patch_id not in applied_patches:
+                    self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
+
+        # Return to original branch
+        self._repo.hgit.checkout(current_branch)
 
     def _collect_all_version_patches(self, version: str) -> List[str]:
         """
@@ -2249,6 +2323,24 @@ class ReleaseManager:
         except Exception as e:
             raise ReleaseManagerError(f"Failed to checkout release branch: {e}")
 
+        # Generate release schema file
+        # Use existing release schema as base if available, otherwise use prod
+        try:
+            base_release = self._find_base_release_schema(version)
+            if base_release:
+                self._repo.restore_database_from_release_schema(base_release)
+            else:
+                self._repo.restore_database_from_schema()
+
+            release_schema_path = self._repo.generate_release_schema(version)
+
+            # Commit release schema on release branch
+            self._repo.hgit.add(str(release_schema_path))
+            self._repo.hgit.commit('-m', f"[HOP] Add release schema for %{version}")
+            self._repo.hgit.push()
+        except Exception as e:
+            raise ReleaseManagerError(f"Failed to generate release schema: {e}")
+
         return {
             'version': version,
             'branch': release_branch,
@@ -2289,6 +2381,53 @@ class ReleaseManager:
         patches_files.sort(key=version_key)
         return patches_files[0].stem.replace('-patches', '')
 
+    def _find_base_release_schema(self, new_version: str) -> Optional[str]:
+        """
+        Find the base release schema for a new release.
+
+        When creating a new release, determines which schema to use as base:
+        - If a release with lower version exists and has a release schema, use it
+        - Otherwise, return None (will use production schema)
+
+        This handles parallel releases:
+        - Creating 0.18.0 (minor) when 0.17.1 (patch) exists → use release-0.17.1.sql
+
+        Note: Only one release per level can exist at a time (sequential promotion rule).
+
+        Args:
+            new_version: Version being created (e.g., "0.18.0")
+
+        Returns:
+            Version string of base release, or None if should use prod schema
+        """
+        from packaging.version import Version
+
+        new_ver = Version(new_version)
+        model_dir = Path(self._repo.model_dir)
+
+        # Find all existing release schema files
+        release_schemas = list(model_dir.glob("release-*.sql"))
+        if not release_schemas:
+            return None
+
+        # Find the release with highest version lower than new_version
+        best_match = None
+        best_ver = None
+
+        for schema_file in release_schemas:
+            match = re.match(r'release-(\d+\.\d+\.\d+)\.sql$', schema_file.name)
+            if match:
+                ver_str = match.group(1)
+                try:
+                    ver = Version(ver_str)
+                    if ver < new_ver and (best_ver is None or ver > best_ver):
+                        best_ver = ver
+                        best_match = ver_str
+                except Exception:
+                    continue
+
+        return best_match
+
     @with_dynamic_branch_lock(lambda self: "ho-prod")
     def promote_to_rc(self) -> dict:
         """
@@ -2355,10 +2494,14 @@ class ReleaseManager:
             # Stay on release branch for rename operations
             # (allows continued development on this release)
 
-            # Create RC snapshot from staged patches
+            # Create RC snapshot from staged patches (with merge_commit)
             rc_file = self._releases_dir / f"{version}-rc{rc_number}.txt"
             staged_patches = release_file.get_patches(status="staged")
-            rc_file.write_text("\n".join(staged_patches) + "\n" if staged_patches else "", encoding='utf-8')
+            lines = []
+            for patch_id in staged_patches:
+                merge_commit = release_file.get_merge_commit(patch_id)
+                lines.append(f"{patch_id}:{merge_commit}" if merge_commit else patch_id)
+            rc_file.write_text("\n".join(lines) + "\n" if lines else "", encoding='utf-8')
 
             # Keep TOML file for continued development (don't delete it)
 
@@ -2498,29 +2641,13 @@ class ReleaseManager:
                         "ho-prod has been restored to its previous state."
                     )
 
-            # 3. Apply only NEW patches from TOML file (if any) and generate schema
-            # Note: RC patches have already been applied during promote_to_rc
-            stage_patches = release_file.get_patches(status="staged")
-
-            if stage_patches:
-                # There are new patches after RC - apply them
-                # First, restore from latest RC schema
-                latest_rc = self._get_latest_label_number(version, "rc")
-                rc_schema_version = f"{version}-rc{latest_rc}" if latest_rc > 0 else "0.0.0"
-
-                # Restore from RC schema if it exists, otherwise from baseline
-                try:
-                    self._repo.restore_database_from_schema(rc_schema_version)
-                except:
-                    self._repo.restore_database_from_schema()
-
-                # Apply new stage patches
-                for patch_id in stage_patches:
-                    self._repo.patch_manager.apply_patch_files(patch_id, self._repo.model)
-            else:
-                # No new patches - just restore from latest RC
-                # The database should already be in the correct state from RC
-                pass
+            # 3. Apply all patches (RC + staged) to database
+            # Uses _apply_release_patches which handles:
+            # - Reading RC files with merge_commits (patch_id:merge_commit format)
+            # - Checking out each merge_commit before applying patch
+            # - Reading staged patches from TOML with merge_commits
+            # force_apply=True to validate by applying patches even if release schema exists
+            self._apply_release_patches(version, force_apply=True)
 
             # Register the release version in half_orm_meta.hop_release
             version_parts = version.split('.')
@@ -2542,6 +2669,11 @@ class ReleaseManager:
             if toml_file.exists():
                 toml_file.unlink()
 
+            # Delete release schema file (no longer needed - prod schema takes over)
+            release_schema_file = model_dir / f"release-{version}.sql"
+            if release_schema_file.exists():
+                release_schema_file.unlink()
+
             # Generate model/data-X.Y.Z.sql if any patches have @HOP:data files
             # This file is used for from-scratch installations (clone, restore)
             prod_patches = self.read_release_patches(prod_file.name)

half_orm_dev/repo.py

@@ -2282,6 +2282,130 @@ See docs/half_orm_dev.md for complete documentation.
             # Catch any unexpected errors
             raise RepoError(f"Database restoration failed: {e}") from e
 
+    def generate_release_schema(self, version: str) -> Path:
+        """
+        Generate release schema SQL dump.
+
+        Creates .hop/model/release-{version}.sql with current database structure,
+        metadata, and data. This file represents the complete state of a release
+        in development (prod + all staged patches).
+
+        Used by:
+        - release create: Generate initial release schema from prod baseline
+        - patch merge: Update release schema after patch integration
+
+        Args:
+            version: Release version string (e.g., "0.17.1", "0.18.0")
+
+        Returns:
+            Path to generated release schema file
+
+        Raises:
+            RepoError: If pg_dump fails or model_dir doesn't exist
+
+        Examples:
+            # After merging patch into release
+            schema_path = repo.generate_release_schema("0.17.1")
+            # Creates: .hop/model/release-0.17.1.sql
+        """
+        model_dir = Path(self.model_dir)
+
+        if not model_dir.exists():
+            raise RepoError(f"Model directory does not exist: {model_dir}")
+
+        release_schema_file = model_dir / f"release-{version}.sql"
+        temp_file = model_dir / f".release-{version}.sql.tmp"
+
+        try:
+            # Dump complete database (schema + data) to temp file
+            self.database.execute_pg_command(
+                'pg_dump',
+                self.name,
+                '--no-owner',
+                '-f',
+                str(temp_file)
+            )
+
+            # Filter out version-specific lines for cross-version compatibility
+            content = temp_file.read_text()
+            filtered_lines = []
+            version_specific_sets = (
+                'SET transaction_timeout',  # PG17+
+            )
+            for line in content.split('\n'):
+                if line.startswith('\\restrict') or line.startswith('\\unrestrict'):
+                    continue
+                if line.startswith('-- Dumped from') or line.startswith('-- Dumped by'):
+                    continue
+                if any(line.startswith(s) for s in version_specific_sets):
+                    continue
+                filtered_lines.append(line)
+
+            release_schema_file.write_text('\n'.join(filtered_lines))
+
+            return release_schema_file
+
+        except Exception as e:
+            raise RepoError(f"Failed to generate release schema: {e}") from e
+        finally:
+            if temp_file.exists():
+                temp_file.unlink()
+
+    def restore_database_from_release_schema(self, version: str) -> None:
+        """
+        Restore database from release schema file.
+
+        Restores database from .hop/model/release-{version}.sql which contains
+        the complete state of a release in development (prod + staged patches).
+
+        If the release schema file doesn't exist, falls back to
+        restore_database_from_schema() for backward compatibility.
+
+        Args:
+            version: Release version string (e.g., "0.17.1")
+
+        Raises:
+            RepoError: If restoration fails
+
+        Examples:
+            # Before applying a candidate patch
+            repo.restore_database_from_release_schema("0.17.1")
+            # Database now has prod schema + all staged patches for 0.17.1
+        """
+        release_schema_path = Path(self.model_dir) / f"release-{version}.sql"
+
+        # Fallback to production schema if release schema doesn't exist
+        if not release_schema_path.exists():
+            self.restore_database_from_schema()
+            return
+
+        try:
+            # Drop all user schemas
+            self._reset_database_schemas()
+
+            # Load release schema
+            self.database.execute_pg_command(
+                'psql', '-d', self.name, '-f', str(release_schema_path)
+            )
+
+            # Reload half_orm metadata cache
+            self.model.reconnect(reload=True)
+
+        except Exception as e:
+            raise RepoError(f"Failed to restore from release schema: {e}") from e
+
+    def get_release_schema_path(self, version: str) -> Path:
+        """
+        Get path to release schema file.
+
+        Args:
+            version: Release version string
+
+        Returns:
+            Path to .hop/model/release-{version}.sql (may not exist)
+        """
+        return Path(self.model_dir) / f"release-{version}.sql"
+
     def _deduce_metadata_path(self, schema_path: Path) -> Path | None:
         """
         Deduce metadata file path from schema.sql symlink target.

half_orm_dev/version.txt

@@ -1 +1 @@
-0.17.3-a8
+0.17.3-a9

{half_orm_dev-0.17.3a8.dist-info → half_orm_dev-0.17.3a9.dist-info}/METADATA

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a8
+Version: 0.17.3a9
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later

{half_orm_dev-0.17.3a8.dist-info → half_orm_dev-0.17.3a9.dist-info}/RECORD

@@ -5,13 +5,13 @@ half_orm_dev/decorators.py,sha256=JKv_Z_JZUr-s-Vz551temHZhhecPfbvyhTbByRDjVAQ,49
 half_orm_dev/hgit.py,sha256=VdzCCQ__xG1IGJaGq4-rrhbA1bNkDw_dBqkUNIeTONg,58045
 half_orm_dev/migration_manager.py,sha256=9RpciH8nyQrF0xV31kAeaYKkQl24Di1VHt-mAjjHhzM,14854
 half_orm_dev/modules.py,sha256=4jfVb2yboRgb9mcO0sMF-iLigcZFTHEm4VRLN6GQXM4,16796
-half_orm_dev/patch_manager.py,sha256=HAnQR4m8E0hyKCpPme_XiHI4K7qFkCT2DvSgCaa524s,100993
+half_orm_dev/patch_manager.py,sha256=yFVaSDid6VJAclQre-J-QWjyDIDNHi6EzRybtMEguow,110669
 half_orm_dev/patch_validator.py,sha256=QNe1L6k_xwsnrOTcb3vkW2D0LbqrCRcZOGPnVyspVRk,10871
-half_orm_dev/release_file.py,sha256=0c9NBhAQ6YpiC3HWj8VtZcfvvZxW2ITk1NEQ60AO0sI,9880
-half_orm_dev/release_manager.py,sha256=AXjjtIWAdv0yy6DkP_eGYKqDDvejmbxnz_QiMRLvwws,125510
-half_orm_dev/repo.py,sha256=ujFY8byccjWPhRX0KmRpVOTJXzJhoS71hKATRinmdtk,96267
+half_orm_dev/release_file.py,sha256=2sfWYqjqfOuMtPDH6qNanXUD9UMaZ7yt912o6aZ0GYI,10570
+half_orm_dev/release_manager.py,sha256=IBjQ26ostzXYu5PF-cx-Z7Wezt8SpG9SkeoTnTNFt2c,130985
+half_orm_dev/repo.py,sha256=W14IR-G737QgVgWV6FMC3zVJfG87X9VbzOC3DLJoJng,100601
 half_orm_dev/utils.py,sha256=M3yViUFfsO7Cp9MYSoUSkCZ6R9w_4jW45UDZUOT8FhI,1493
-half_orm_dev/version.txt,sha256=wYr2Q8o9RjL8C7XzKe_XYG7tTQ2r67CNUTt48ebDpks,10
+half_orm_dev/version.txt,sha256=mcwJgjmZIdLLkWl4QWMi2Zy-eHfrnal7--Y_GUibulg,10
 half_orm_dev/cli/__init__.py,sha256=0CbMj8OIhZmglWakK7NhYPn302erUTEg2VHOdm1hRTQ,163
 half_orm_dev/cli/main.py,sha256=3SVTl5WraNTSY6o7LfvE1dUHKg_RcuVaHHDIn_oINv4,11701
 half_orm_dev/cli/commands/__init__.py,sha256=UhWf0AnWqy4gyFo2SJQv8pL_YJ43pE_c9TgopcjzKDg,1490
@@ -30,6 +30,7 @@ half_orm_dev/cli/commands/update.py,sha256=OarpDkC8hF08UUv1l2i-2qpHICgpB6WDn9ziY
 half_orm_dev/cli/commands/upgrade.py,sha256=9puvnanp6D2n3cQGcmK1-AI6Z_GlTYPZcaZgN1m5wDE,6297
 half_orm_dev/migrations/0/17/1/00_move_to_hop.py,sha256=esXYcdgNUJfUQUCtD_BBxHbdQi7_s4nWJ8bJYNIUfY4,4000
 half_orm_dev/migrations/0/17/1/01_txt_to_toml.py,sha256=CJQo4-DTI0tPBD6VXNo0HsNkG2fkSxHAcQ-5cwXVt_4,4995
+half_orm_dev/migrations/0/17/4/00_toml_dict_format.py,sha256=5LYVExrAhVmS_Fkp2uhs9j5xtWrp3FhzDhrwn3_CQdI,6224
 half_orm_dev/patches/log,sha256=n7MNnGR09Obd87gXLzIi6zA76sI4RhOJzC25wb0TbKE,22
 half_orm_dev/patches/0/1/0/00_half_orm_meta.database.sql,sha256=gMZ94YlyrftxcqDn0l-ToCTee4A_bnP58DpHcIT_T1w,1074
 half_orm_dev/patches/0/1/0/01_alter_half_orm_meta.hop_release.sql,sha256=nhRbDi6sUenvVfOnoRuWSbLEC1cEfzrXbxDof2weq04,183
@@ -51,9 +52,9 @@ half_orm_dev/templates/sql_adapter,sha256=kAP5y7Qml3DKsbZLUeoVpeXjbQcWltHjkDznED
 half_orm_dev/templates/warning,sha256=4hlZ_rRdpmkXxOeRoVd9xnXBARYXn95e-iXrD1f2u7k,490
 half_orm_dev/templates/git-hooks/pre-commit,sha256=Hf084pqeiOebrv4xzA0aiaHbIXswmmNO-dSIXUfzMK0,4707
 half_orm_dev/templates/git-hooks/prepare-commit-msg,sha256=zknOGGoaWKC97zfga2Xl2i_psnNo9MJbrEBuN91eHNw,1070
-half_orm_dev-0.17.3a8.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
-half_orm_dev-0.17.3a8.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
-half_orm_dev-0.17.3a8.dist-info/METADATA,sha256=XiSW9K2OPEnPJW8tO0AUl8-Zt4Hqz8DvIc6SKX4q2xg,16149
-half_orm_dev-0.17.3a8.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
-half_orm_dev-0.17.3a8.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
-half_orm_dev-0.17.3a8.dist-info/RECORD,,
+half_orm_dev-0.17.3a9.dist-info/licenses/AUTHORS,sha256=eWxqzRdLOt2gX0FMQj_wui03Od3jdlwa8xNe9tl84g0,113
+half_orm_dev-0.17.3a9.dist-info/licenses/LICENSE,sha256=ufhxlSi6mttkGQTsGWrEoB3WA_fCPJ6-k07GSVBgyPw,644
+half_orm_dev-0.17.3a9.dist-info/METADATA,sha256=5j_555Q9_75zj0GZADXj-PUEf-lXJ7xL-v5tZJzWO7w,16149
+half_orm_dev-0.17.3a9.dist-info/WHEEL,sha256=wUyA8OaulRlbfwMtmQsvNngGrxQHAvkKcvRmdizlJi0,92
+half_orm_dev-0.17.3a9.dist-info/top_level.txt,sha256=M5hEsWfn5Kw0HL-VnNmS6Jw-3cwRyjims5a8cr18eTM,13
+half_orm_dev-0.17.3a9.dist-info/RECORD,,