half-orm-dev 0.17.3a8__tar.gz → 0.17.3a9__tar.gz

{half_orm_dev-0.17.3a8/half_orm_dev.egg-info → half_orm_dev-0.17.3a9}/PKG-INFO

@@ -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.3a9/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-0.17.3a8 → half_orm_dev-0.17.3a9}/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))