half-orm-dev 0.17.3a9__tar.gz → 0.17.4a2__tar.gz

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 0.17.3a9
+Version: 0.17.4a2
 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.4a2/half_orm_dev/bootstrap_manager.py

@@ -0,0 +1,334 @@
+"""
+BootstrapManager module for half-orm-dev
+
+Manages bootstrap scripts for data initialization. Bootstrap files are
+SQL and Python scripts that initialize application data after database setup.
+
+Files are named: <number>-<patch_id>-<version>.<ext>
+Example: 1-init-users-0.1.0.sql, 2-seed-config-0.1.0.py
+
+Scripts are executed in numeric order and tracked in half_orm_meta.bootstrap table.
+"""
+
+from __future__ import annotations
+
+import re
+import click
+from pathlib import Path
+from typing import List, Set, Tuple, Optional, TYPE_CHECKING
+
+from half_orm_dev.file_executor import (
+    execute_sql_file, execute_python_file, FileExecutionError
+)
+
+if TYPE_CHECKING:
+    from half_orm_dev.repo import Repo
+
+
+class BootstrapManagerError(Exception):
+    """Base exception for BootstrapManager operations."""
+    pass
+
+
+class BootstrapManager:
+    """
+    Manages bootstrap scripts for data initialization.
+
+    Bootstrap scripts are SQL and Python files that initialize application
+    data after the database schema is created. They are tracked in the
+    half_orm_meta.bootstrap table to ensure each script is executed only once.
+
+    Attributes:
+        _repo: Repository instance
+        _bootstrap_dir: Path to bootstrap/ directory
+    """
+
+    def __init__(self, repo: 'Repo'):
+        """
+        Initialize BootstrapManager.
+
+        Args:
+            repo: Repository instance
+        """
+        self._repo = repo
+        self._bootstrap_dir = Path(repo.base_dir) / 'bootstrap'
+
+    @property
+    def bootstrap_dir(self) -> Path:
+        """Get path to bootstrap directory."""
+        return self._bootstrap_dir
+
+    def _ensure_bootstrap_table(self) -> None:
+        """
+        Ensure half_orm_meta.bootstrap table exists.
+
+        Creates the table if it doesn't exist. This handles the case
+        where the table hasn't been created yet (pre-migration databases).
+        """
+        sql = """
+        CREATE TABLE IF NOT EXISTS half_orm_meta.bootstrap (
+            filename TEXT PRIMARY KEY,
+            version TEXT NOT NULL,
+            executed_at TIMESTAMP DEFAULT NOW()
+        );
+        """
+        try:
+            self._repo.database.model.execute_query(sql)
+        except Exception:
+            # Schema might not exist yet, ignore
+            pass
+
+    def get_bootstrap_files(self) -> List[Path]:
+        """
+        List bootstrap files sorted by numeric prefix.
+
+        Returns files matching pattern: <number>-<patch_id>-<version>.<ext>
+        Sorted numerically on the first field (not lexicographically).
+
+        Returns:
+            List of Path objects for bootstrap files in execution order
+        """
+        if not self._bootstrap_dir.exists():
+            return []
+
+        files = []
+        for file_path in self._bootstrap_dir.iterdir():
+            if file_path.is_file() and file_path.suffix in ('.sql', '.py'):
+                # Skip README or other non-bootstrap files
+                if not re.match(r'^\d+-', file_path.name):
+                    continue
+                files.append(file_path)
+
+        # Sort by numeric prefix
+        def get_numeric_prefix(path: Path) -> int:
+            match = re.match(r'^(\d+)-', path.name)
+            return int(match.group(1)) if match else 0
+
+        return sorted(files, key=get_numeric_prefix)
+
+    def get_executed_files(self) -> Set[str]:
+        """
+        Get set of already executed filenames from database.
+
+        Queries half_orm_meta.bootstrap table to get filenames
+        that have already been executed.
+
+        Returns:
+            Set of filename strings that have been executed
+        """
+        # Ensure table exists before querying
+        self._ensure_bootstrap_table()
+
+        try:
+            result = self._repo.database.model.execute_query(
+                "SELECT filename FROM half_orm_meta.bootstrap"
+            )
+            return {row[0] for row in result} if result else set()
+        except Exception:
+            # Table might not exist yet (pre-migration)
+            return set()
+
+    def get_pending_files(self) -> List[Path]:
+        """
+        Get bootstrap files not yet executed.
+
+        Returns:
+            List of Path objects for files pending execution
+        """
+        all_files = self.get_bootstrap_files()
+        executed = self.get_executed_files()
+
+        return [f for f in all_files if f.name not in executed]
+
+    def execute_file(self, file_path: Path) -> None:
+        """
+        Execute SQL or Python bootstrap file.
+
+        Args:
+            file_path: Path to bootstrap file
+
+        Raises:
+            BootstrapManagerError: If execution fails
+        """
+        try:
+            if file_path.suffix == '.sql':
+                execute_sql_file(file_path, self._repo.database.model)
+            elif file_path.suffix == '.py':
+                output = execute_python_file(file_path, cwd=self._bootstrap_dir)
+                if output:
+                    click.echo(f"    Output: {output}")
+            else:
+                raise BootstrapManagerError(
+                    f"Unsupported file type: {file_path.suffix}"
+                )
+        except FileExecutionError as e:
+            raise BootstrapManagerError(str(e)) from e
+
+    def record_execution(self, filename: str, version: str) -> None:
+        """
+        Record execution in half_orm_meta.bootstrap table.
+
+        Args:
+            filename: Name of the executed file
+            version: Version extracted from filename
+        """
+        sql = """
+        INSERT INTO half_orm_meta.bootstrap (filename, version)
+        VALUES (%s, %s)
+        ON CONFLICT (filename) DO UPDATE SET
+            version = EXCLUDED.version,
+            executed_at = NOW()
+        """
+        self._repo.database.model.execute_query(sql, (filename, version))
+
+    def run_bootstrap(
+        self,
+        dry_run: bool = False,
+        force: bool = False,
+        exclude_patch_id: Optional[str] = None
+    ) -> dict:
+        """
+        Execute pending bootstrap files.
+
+        Args:
+            dry_run: If True, show what would be executed without executing
+            force: If True, re-execute all files (ignore tracking)
+            exclude_patch_id: If provided, skip files belonging to this patch
+                             (used during patch apply to avoid executing the
+                             bootstrap file that was just created for the current patch)
+
+        Returns:
+            Dict with execution results:
+            - 'executed': List of executed filenames
+            - 'skipped': List of skipped filenames (already executed)
+            - 'excluded': List of excluded filenames (matching exclude_patch_id)
+            - 'errors': List of (filename, error) tuples
+        """
+        result = {
+            'executed': [],
+            'skipped': [],
+            'excluded': [],
+            'errors': []
+        }
+
+        if force:
+            files_to_execute = self.get_bootstrap_files()
+        else:
+            files_to_execute = self.get_pending_files()
+            # Calculate skipped
+            all_files = self.get_bootstrap_files()
+            executed = self.get_executed_files()
+            result['skipped'] = [f.name for f in all_files if f.name in executed]
+
+        if not files_to_execute:
+            return result
+
+        for file_path in files_to_execute:
+            filename = file_path.name
+            version = self._extract_version_from_filename(filename)
+
+            # Check if this file belongs to the excluded patch
+            if exclude_patch_id and self._file_belongs_to_patch(filename, exclude_patch_id):
+                result['excluded'].append(filename)
+                continue
+
+            if dry_run:
+                result['executed'].append(filename)
+                continue
+
+            try:
+                click.echo(f"  • Executing {filename}...")
+                self.execute_file(file_path)
+                self.record_execution(filename, version)
+                result['executed'].append(filename)
+            except BootstrapManagerError as e:
+                result['errors'].append((filename, str(e)))
+                # Stop on first error
+                break
+
+        return result
+
+    def _parse_filename(self, filename: str) -> Tuple[int, str, str]:
+        """
+        Parse bootstrap filename into components.
+
+        Expected format: <number>-<patch_id>-<version>.<ext>
+        Example: '1-init-users-0.1.0.sql' -> (1, 'init-users', '0.1.0')
+
+        Args:
+            filename: Bootstrap filename to parse
+
+        Returns:
+            Tuple of (number, patch_id, version)
+
+        Raises:
+            ValueError: If filename doesn't match expected format
+        """
+        # Pattern: number-patch_id-X.Y.Z.ext
+        match = re.match(r'^(\d+)-(.+)-(\d+\.\d+\.\d+)\.(sql|py)$', filename)
+        if not match:
+            raise ValueError(f"Invalid bootstrap filename format: {filename}")
+
+        number = int(match.group(1))
+        patch_id = match.group(2)
+        version = match.group(3)
+
+        return number, patch_id, version
+
+    def _file_belongs_to_patch(self, filename: str, patch_id: str) -> bool:
+        """
+        Check if a bootstrap file belongs to a specific patch.
+
+        Args:
+            filename: Bootstrap filename (e.g., '1-my-patch-0.1.0.sql')
+            patch_id: Patch identifier to check against
+
+        Returns:
+            True if the file belongs to the patch, False otherwise
+        """
+        try:
+            _, file_patch_id, _ = self._parse_filename(filename)
+            return file_patch_id == patch_id
+        except ValueError:
+            return False
+
+    def _extract_version_from_filename(self, filename: str) -> str:
+        """
+        Extract version from bootstrap filename.
+
+        Args:
+            filename: Bootstrap filename
+
+        Returns:
+            Version string or 'unknown' if parsing fails
+        """
+        try:
+            _, _, version = self._parse_filename(filename)
+            return version
+        except ValueError:
+            return 'unknown'
+
+    def get_next_bootstrap_number(self) -> int:
+        """
+        Get next available number for bootstrap file.
+
+        Returns:
+            Next number (1-based) for naming a new bootstrap file
+        """
+        files = self.get_bootstrap_files()
+        if not files:
+            return 1
+
+        # Get max number from existing files
+        max_num = 0
+        for file_path in files:
+            match = re.match(r'^(\d+)-', file_path.name)
+            if match:
+                num = int(match.group(1))
+                max_num = max(max_num, num)
+
+        return max_num + 1
+
+    def ensure_bootstrap_dir(self) -> None:
+        """Create bootstrap directory if it doesn't exist."""
+        self._bootstrap_dir.mkdir(exist_ok=True)

{half_orm_dev-0.17.3a9 → half_orm_dev-0.17.4a2}/half_orm_dev/cli/commands/__init__.py

@@ -14,6 +14,7 @@ from .update import update
 from .upgrade import upgrade
 from .check import check
 from .migrate import migrate
+from .bootstrap import bootstrap
 from .todo import apply_release
 from .todo import rollback
 
@@ -32,6 +33,7 @@ ALL_COMMANDS = {
     'upgrade': upgrade,          # Adapted for production
     'check': check,            # Project health check and updates
     'migrate': migrate,        # Repository migration after upgrade
+    'bootstrap': bootstrap,    # Execute data initialization scripts
     # 🚧 (stubs)
     'apply_release': apply_release,
 
@@ -52,6 +54,7 @@ __all__ = [
     'upgrade',
     'check',
     'migrate',
+    'bootstrap',
     'rollback',
     # Adapted commands
     'sync_package',

half_orm_dev-0.17.4a2/half_orm_dev/cli/commands/bootstrap.py

@@ -0,0 +1,139 @@
+"""
+Bootstrap command - Execute data initialization scripts.
+
+Runs bootstrap scripts from the bootstrap/ directory to initialize
+application data after database setup.
+"""
+
+import click
+from half_orm_dev.repo import Repo
+from half_orm_dev.bootstrap_manager import BootstrapManager, BootstrapManagerError
+from half_orm import utils
+
+
+@click.command()
+@click.option(
+    '--dry-run',
+    is_flag=True,
+    help='Show what would be executed without executing'
+)
+@click.option(
+    '--force',
+    is_flag=True,
+    help='Re-execute all files (ignore tracking)'
+)
+@click.option(
+    '--verbose', '-v',
+    is_flag=True,
+    help='Show detailed information'
+)
+def bootstrap(dry_run: bool, force: bool, verbose: bool) -> None:
+    """
+    Execute bootstrap scripts to initialize application data.
+
+    Bootstrap scripts are SQL and Python files in the bootstrap/ directory
+    that initialize application data after the database schema is created.
+
+    Files are named: <number>-<patch_id>-<version>.<ext>
+    Example: 1-init-users-0.1.0.sql, 2-seed-config-0.1.0.py
+
+    Scripts are executed in numeric order and tracked in the database
+    to ensure each script is executed only once.
+
+    EXAMPLES:
+        # Execute pending bootstrap scripts
+        half_orm dev bootstrap
+
+        # Preview what would be executed
+        half_orm dev bootstrap --dry-run
+
+        # Re-execute all scripts (ignore tracking)
+        half_orm dev bootstrap --force
+
+    NOTES:
+        - SQL files are executed via halfORM
+        - Python files are executed as subprocesses
+        - Execution is tracked in half_orm_meta.bootstrap table
+        - Use --force to re-execute previously run scripts
+    """
+    try:
+        repo = Repo()
+        bootstrap_mgr = BootstrapManager(repo)
+
+        # Check if bootstrap directory exists
+        if not bootstrap_mgr.bootstrap_dir.exists():
+            click.echo(f"ℹ️  No bootstrap directory found at {bootstrap_mgr.bootstrap_dir}")
+            click.echo(f"   Create bootstrap/ directory with data scripts to use this command.")
+            return
+
+        # Get files info
+        all_files = bootstrap_mgr.get_bootstrap_files()
+        if not all_files:
+            click.echo(f"ℹ️  No bootstrap files found in {bootstrap_mgr.bootstrap_dir}")
+            return
+
+        # Display header
+        if dry_run:
+            click.echo(f"🔍 {utils.Color.bold('Dry run mode')} - showing what would be executed")
+            click.echo()
+
+        if force:
+            click.echo(f"⚠️  {utils.Color.bold('Force mode')} - re-executing all files")
+            click.echo()
+
+        # Run bootstrap
+        result = bootstrap_mgr.run_bootstrap(dry_run=dry_run, force=force)
+
+        # Display results
+        _display_results(result, dry_run, verbose)
+
+    except BootstrapManagerError as e:
+        click.echo(utils.Color.red(f"❌ Bootstrap error: {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"❌ Error: {e}"), err=True)
+        if verbose:
+            import traceback
+            traceback.print_exc()
+        raise click.Abort()
+
+
+def _display_results(result: dict, dry_run: bool, verbose: bool) -> None:
+    """Display bootstrap execution results."""
+    executed = result.get('executed', [])
+    skipped = result.get('skipped', [])
+    errors = result.get('errors', [])
+
+    # Display executed files
+    if executed:
+        verb = "Would execute" if dry_run else "Executed"
+        click.echo(f"✓ {utils.Color.green(f'{verb} {len(executed)} file(s):')}")
+        for filename in executed:
+            click.echo(f"  • {filename}")
+        click.echo()
+
+    # Display skipped files (already executed)
+    if skipped and verbose:
+        click.echo(f"ℹ️  {utils.Color.blue(f'Skipped {len(skipped)} already executed file(s):')}")
+        for filename in skipped:
+            click.echo(f"  • {filename}")
+        click.echo()
+    elif skipped and not verbose:
+        click.echo(f"ℹ️  Skipped {len(skipped)} already executed file(s) (use -v to see list)")
+        click.echo()
+
+    # Display errors
+    if errors:
+        click.echo(utils.Color.red(f"❌ {len(errors)} error(s) occurred:"))
+        for filename, error_msg in errors:
+            click.echo(f"  • {filename}: {error_msg}")
+        click.echo()
+
+    # Summary
+    if not executed and not errors:
+        if skipped:
+            click.echo(f"✓ {utils.Color.green('All bootstrap files have already been executed.')}")
+        else:
+            click.echo(f"ℹ️  No bootstrap files to execute.")
+    elif not errors and not dry_run:
+        click.echo(f"✓ {utils.Color.green('Bootstrap completed successfully.')}")

{half_orm_dev-0.17.3a9 → half_orm_dev-0.17.4a2}/half_orm_dev/cli/commands/check.py

@@ -117,6 +117,25 @@ def _display_check_results(repo, result: dict, dry_run: bool, verbose: bool):
     elif verbose:
         click.echo(f"✓ {utils.Color.green('Pre-commit hook up to date')}")
 
+    # Branch sync results
+    branch_sync = result.get('branch_sync', {})
+    synced = branch_sync.get('synced', [])
+    created = branch_sync.get('created', [])
+    sync_errors = branch_sync.get('errors', [])
+
+    if synced or created:
+        total = len(synced) + len(created)
+        click.echo(f"\n🔄 {utils.Color.bold('Branches synchronized')} ({total}):")
+        for branch in synced:
+            click.echo(f"  ✓ {utils.Color.green(branch)} (updated)")
+        for branch in created:
+            click.echo(f"  ✓ {utils.Color.green(branch)} (new)")
+
+    if sync_errors:
+        click.echo(f"\n⚠️  {utils.Color.bold('Sync errors')} ({len(sync_errors)}):")
+        for branch, error in sync_errors:
+            click.echo(f"  ✗ {utils.Color.red(branch)}: {error}")
+
     # Active branches
     active = result.get('active_branches', {})
     patch_branches = active.get('patch_branches', [])

{half_orm_dev-0.17.3a9 → half_orm_dev-0.17.4a2}/half_orm_dev/cli/commands/clone.py

@@ -14,9 +14,13 @@ from half_orm_dev.repo import Repo, RepoError
 @click.argument('git_origin')
 @click.option('--database-name', default=None, help='Custom local database name (default: use project name)')
 @click.option('--dest-dir', default=None, help='Destination directory name (default: infer from git URL)')
+@click.option('--host', default='localhost', help='PostgreSQL host (default: localhost)')
+@click.option('--port', default=5432, type=int, help='PostgreSQL port (default: 5432)')
+@click.option('--user', default=None, help='Database user (default: $USER)')
+@click.option('--password', default=None, help='Database password (prompts if missing)')
 @click.option('--production', is_flag=True, help='Production mode (default: False)')
 @click.option('--no-create-db', is_flag=True, help='Skip database creation (database must exist)')
-def clone(git_origin, database_name, dest_dir, production, no_create_db):
+def clone(git_origin, database_name, dest_dir, host, port, user, password, production, no_create_db):
     """
     Clone existing half_orm_dev project and setup local database.
 
@@ -55,12 +59,21 @@ def clone(git_origin, database_name, dest_dir, production, no_create_db):
         click.echo(f"🔄 Cloning half_orm project from {git_origin}...")
         click.echo()
 
+        # Build connection options
+        connection_options = {
+            'host': host,
+            'port': port,
+            'user': user,
+            'password': password,
+            'production': production
+        }
+
         # Execute clone
         Repo.clone_repo(
             git_origin=git_origin,
             database_name=database_name,
             dest_dir=dest_dir,
-            production=production,
+            connection_options=connection_options,
             create_db=not no_create_db
         )
 

{half_orm_dev-0.17.3a9 → half_orm_dev-0.17.4a2}/half_orm_dev/cli/commands/patch.py

@@ -13,6 +13,7 @@ Replaces legacy commands:
 """
 
 import click
+from pathlib import Path
 from typing import Optional
 
 from half_orm_dev.repo import Repo
@@ -107,7 +108,13 @@ def patch_create(patch_id: str, description: Optional[str] = None, before: Optio
 
 
 @patch.command('apply')
-def patch_apply() -> None:
+@click.option(
+    '--from-dump',
+    type=click.Path(exists=True, dir_okay=False, resolve_path=True),
+    help='Restore from pg_dump SQL file instead of schema.sql. '
+         'Useful for testing with production data.'
+)
+def patch_apply(from_dump: Optional[str]) -> None:
     """
     Apply current patch files to database.
 
@@ -115,15 +122,14 @@ def patch_apply() -> None:
     patch from current branch name and executes complete workflow:
     database restoration, patch application, and code generation.
 
-    This command has no parameters - patch detection is automatic from
-    the current Git branch. All business logic is delegated to
-    PatchManager.apply_patch_complete_workflow().
+    Patch detection is automatic from the current Git branch.
+    All business logic is delegated to PatchManager.apply_patch_complete_workflow().
 
     \b
     Workflow:
         1. Validate current branch is ho-patch/*
         2. Extract patch_id from branch name
-        3. Restore database from model/schema.sql
+        3. Restore database from model/schema.sql (or --from-dump file)
         4. Apply patch SQL/Python files in lexicographic order
         5. Generate halfORM Python code via modules.py
         6. Display detailed report with next steps
@@ -136,9 +142,12 @@ def patch_apply() -> None:
 
     \b
     Examples:
-        On branch ho-patch/456-user-auth:
+        # Standard workflow (restore from schema.sql):
         $ half_orm dev patch apply
 
+        # Using production dump for realistic data:
+        $ half_orm dev patch apply --from-dump /path/to/prod_dump.sql
+
     \b
     Output:
         ✓ Current branch: ho-patch/456-user-auth
@@ -183,15 +192,21 @@ def patch_apply() -> None:
         # Display current context
         click.echo(f"✓ Current branch: {utils.Color.bold(current_branch)}")
         click.echo(f"✓ Detected patch: {utils.Color.bold(patch_id)}")
+        if from_dump:
+            click.echo(f"✓ Using dump file: {utils.Color.bold(from_dump)}")
         click.echo()
 
         # Delegate to PatchManager
         click.echo("Applying patch...")
-        result = repo.patch_manager.apply_patch_complete_workflow(patch_id)
+        dump_path = Path(from_dump) if from_dump else None
+        result = repo.patch_manager.apply_patch_complete_workflow(patch_id, from_dump=dump_path)
 
         # Display success
         click.echo(f"✓ {utils.Color.green('Patch applied successfully!')}")
-        click.echo(f"✓ Database restored from model/schema.sql")
+        if result.get('used_dump'):
+            click.echo(f"✓ Database restored from dump file")
+        else:
+            click.echo(f"✓ Database restored from model/schema.sql")
         click.echo()
 
         # Display applied files

{half_orm_dev-0.17.3a9 → half_orm_dev-0.17.4a2}/half_orm_dev/cli/main.py

@@ -59,10 +59,10 @@ class Hop:
         # Development mode (metadata present)
         if self.__repo.database.production:
             # PRODUCTION ENVIRONMENT - Release deployment only
-            return ['update', 'upgrade', 'check']
+            return ['update', 'upgrade', 'bootstrap']
         else:
             # DEVELOPMENT ENVIRONMENT - Patch development
-            return ['patch', 'release', 'check']
+            return ['patch', 'release', 'check', 'bootstrap']
 
     @property
     def repo_checked(self):