half-orm-dev 1.0.0a32__tar.gz → 1.0.0a33__tar.gz

{half_orm_dev-1.0.0a32/half_orm_dev.egg-info → half_orm_dev-1.0.0a33}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: half_orm_dev
-Version: 1.0.0a32
+Version: 1.0.0a33
 Summary: half_orm development Framework.
 Author-email: Joël Maïzi <joel.maizi@collorg.org>
 License-Expression: GPL-3.0-or-later
@@ -25,7 +25,7 @@ Requires-Dist: packaging
 Requires-Dist: pydash
 Requires-Dist: pytest
 Requires-Dist: pytest-asyncio
-Requires-Dist: half_orm<1.1.0,>=1.0.0a1
+Requires-Dist: half_orm<1.1.0,>=1.0.0rc16
 Requires-Dist: tomli>=2.0.0; python_version < "3.11"
 Requires-Dist: tomli_w>=1.0.0
 Dynamic: license-file

half_orm_dev-1.0.0a33/half_orm_dev/_bootstrap_runner.py

@@ -0,0 +1,39 @@
+"""
+Internal entrypoint for running a single bootstrap script in a project's
+own virtual environment, as a subprocess.
+
+Invoked as:
+    <venv_python> -m half_orm_dev._bootstrap_runner <script_path> <database_name>
+
+Not a public API - used exclusively by
+half_orm_dev.file_executor.execute_python_bootstrap() when a venv_python
+is provided (i.e. the project declared its own dependencies via
+requirements.txt). Running via -m rather than a bare script path avoids
+needing to locate this file on disk from inside the target venv; it only
+needs half_orm_dev importable there, which pip install -e . already
+guarantees (pyproject.toml always depends on half_orm_dev).
+"""
+
+import importlib.util
+import sys
+
+from half_orm.model import Model
+
+
+def main() -> None:
+    script_path, database_name = sys.argv[1], sys.argv[2]
+
+    spec = importlib.util.spec_from_file_location('_bootstrap_script', script_path)
+    module = importlib.util.module_from_spec(spec)
+    spec.loader.exec_module(module)
+
+    run = getattr(module, 'run', None)
+    if run is not None:
+        model = Model(database_name)
+        result = run(model)
+        if result is not None:
+            print(result)
+
+
+if __name__ == '__main__':
+    main()

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/cli/commands/__init__.py

@@ -17,11 +17,11 @@ from .migrate import migrate
 from .revert_migration import revert_migration
 from .rollback import rollback
 from .recover import recover
+from .restore import restore
 from .todo import apply_release
 
 # ♻️ Adapted existing commands
 from .todo import sync_package    # Unchanged
-from .todo import restore      # Adapted for new architecture
 
 # Registry of all available commands - Git-centric architecture
 ALL_COMMANDS = {
@@ -41,10 +41,10 @@ ALL_COMMANDS = {
     # 🚧 Emergency workflow (stubs)
     'rollback': rollback,
     'recover': recover,
+    'restore': restore,
 
     # ♻️ Adapted commands
     'sync-package': sync_package, # Unchanged
-    'restore': restore,          # Adapted
 }
 
 __all__ = [
@@ -58,6 +58,7 @@ __all__ = [
     'migrate',
     'rollback',
     'recover',
+    'restore',
     # Adapted commands
     'sync_package',
     'ALL_COMMANDS'

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/cli/commands/clone.py

@@ -14,8 +14,8 @@ 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('--host', default=None, help='PostgreSQL host (default: $PGHOST, then localhost)')
+@click.option('--port', default=None, type=int, help='PostgreSQL port (default: $PGPORT, then 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)')

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/cli/commands/init.py

@@ -25,8 +25,8 @@ class ProjectDirectoryExistsError(Exception):
 
 @click.command('init')
 @click.argument('project_name')
-@click.option('--host', default='localhost', help='PostgreSQL host (default: localhost)')
-@click.option('--port', default=5432, type=int, help='PostgreSQL port (default: 5432)')
+@click.option('--host', default=None, help='PostgreSQL host (default: $PGHOST, then localhost)')
+@click.option('--port', default=None, type=int, help='PostgreSQL port (default: $PGPORT, then 5432)')
 @click.option('--user', default=None, help='Database user (default: $USER)')
 @click.option('--password', default=None, help='Database password (prompts if missing)')
 @click.option('--git-origin', default=None, help='Git remote origin URL (prompts if missing)')
@@ -34,7 +34,15 @@ class ProjectDirectoryExistsError(Exception):
 @click.option('--force-sync-only', is_flag=True, help='Skip metadata installation, force sync-only mode')
 @click.option('--create-db', is_flag=False, default=True)
 @click.option('--docker', default='', help='Docker container name for PostgreSQL')
-def init(project_name, host, port, user, password, git_origin, production, force_sync_only, create_db, docker):
+@click.option(
+    '--with-meta', is_flag=False, flag_value='__ALL__', default=None,
+    metavar='[NAMES]',
+    help='Expose half_orm_meta data on the generated Model. Bare flag '
+         'exposes everything; pass a comma-separated allowlist of '
+         'fully-qualified relation names to expose only those, e.g. '
+         '--with-meta=half_orm_meta.identity.user'
+)
+def init(project_name, host, port, user, password, git_origin, production, force_sync_only, create_db, docker, with_meta):
     """
     Initialize a new half_orm_dev project with database and code structure.
 
@@ -187,10 +195,18 @@ def init(project_name, host, port, user, password, git_origin, production, force
         click.echo(f"📁 Creating project structure...")
 
         # Now safe to instantiate Repo (database is configured)
+        if with_meta is None:
+            with_half_orm_meta = False
+        elif with_meta == '__ALL__':
+            with_half_orm_meta = True
+        else:
+            with_half_orm_meta = with_meta
+
         repo = Repo()
         repo.init_git_centric_project(
             package_name=package_name,
-            git_origin=git_origin
+            git_origin=git_origin,
+            with_half_orm_meta=with_half_orm_meta
         )
 
         # ============================================================

half_orm_dev-1.0.0a33/half_orm_dev/cli/commands/restore.py

@@ -0,0 +1,62 @@
+"""
+Restore command - Restore the development database to a given release.
+"""
+
+from pathlib import Path
+
+import click
+from half_orm_dev.repo import Repo, RepoError
+from half_orm import utils
+
+
+@click.command()
+@click.argument('release')
+def restore(release: str) -> None:
+    """
+    Restore the database to the state of RELEASE.
+
+    Drops all user schemas and reloads them, picking the most precise
+    snapshot available for RELEASE:
+
+    \b
+    1. .hop/model/release-RELEASE.sql   (production + patches staged
+       for that release, still in development)
+    2. .hop/model/schema-RELEASE.sql    (published snapshot of that
+       exact released version)
+
+    Fails with an error, rather than silently loading a different
+    version, if neither file exists.
+
+    \b
+    Examples:
+        # Restore to a release currently in development
+        half_orm dev restore 0.17.1
+
+        # Restore to an already-published version
+        half_orm dev restore 0.3.5
+    """
+    try:
+        repo = Repo()
+        click.echo(f"Restoring database to release {utils.Color.bold(release)}...")
+
+        release_schema_path = repo.get_release_schema_path(release)
+        schema_path = Path(repo.model_dir) / f"schema-{release}.sql"
+
+        if release_schema_path.exists():
+            repo.restore_database_from_release_schema(release)
+        elif schema_path.exists():
+            repo.restore_database_from_version_schema(release)
+        else:
+            raise RepoError(
+                f"No schema found for release '{release}': neither "
+                f"{release_schema_path.name} nor {schema_path.name} "
+                f"exists in {repo.model_dir}."
+            )
+
+        click.echo(f"✓ {utils.Color.green('Database restored to')} {utils.Color.bold(release)}")
+    except RepoError as e:
+        click.echo(utils.Color.red(f"\n❌ {e}"), err=True)
+        raise click.Abort()
+    except Exception as e:
+        click.echo(utils.Color.red(f"\n❌ Unexpected error: {e}"), err=True)
+        raise click.Abort()

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/cli/commands/todo.py

@@ -42,7 +42,6 @@ def todo(ctx):
         'create-hotfix': 'Create emergency hotfix bypassing normal workflow',
         'rollback': 'Rollback database to previous version using backups/',
         'sync-package': 'Synchronize Python package with database model',
-        'restore': 'Restore database to specific version (adapt for new backups)',
         'list-patches': 'List all patches in Patches/ directory',
         'status': 'Show development status with patch/release information',
         'apply-release': 'Apply next release',
@@ -70,4 +69,3 @@ status = todo
 
 # ♻️ Commands to adapt (also in todo for now)
 sync_package = todo   # Keep functionality, adapt to new architecture
-restore = todo        # Adapt for new backup/restore logic

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/cli/main.py

@@ -61,7 +61,7 @@ class Hop:
 
         # DEVELOPMENT ENVIRONMENT - Patch development
         return ['patch', 'release', 'check', 'set-git-origin',
-                'revert-migration', 'recover']
+                'revert-migration', 'recover', 'restore']
 
     @property
     def repo_checked(self):

{half_orm_dev-1.0.0a32 → half_orm_dev-1.0.0a33}/half_orm_dev/database.py

@@ -81,7 +81,9 @@ class Database:
         db_name = self.__repo.database_name
         if db_name:
             try:
-                self.__model = Model(db_name)
+                self.__model = Model(
+                    db_name, with_half_orm_meta=self.__repo.with_half_orm_meta,
+                )
                 self.__init(db_name, get_release)
             except OperationalError as err:
                 if not self.__repo.new:
@@ -175,10 +177,10 @@ class Database:
                     major=0, minor=0, patch=0, changelog='Initial release')
         return self(self.__name)
 
-    def execute_pg_command(self, *command_args):
+    def execute_pg_command(self, *command_args, database_name=None):
         """Execute PostgreSQL command with instance's connection parameters."""
         return self._execute_pg_command(
-            self.__name,
+            database_name or self.__name,
             self._get_connection_params(),
             *command_args
         )
@@ -206,9 +208,12 @@ class Database:
         Generate versioned schema SQL dump.
 
         Creates model/schema-{version}.sql with current database structure
-        using pg_dump --schema-only. Creates model/metadata-{version}.sql
-        with half_orm_meta data using pg_dump --data-only.
-        Updates model/schema.sql symlink to point to the new version.
+        using pg_dump --schema-only. Creates model/data-{version}.sql with
+        the complete data snapshot (half_orm_meta bookkeeping + all
+        application data) using pg_dump --data-only, so a fresh instance
+        restored from these two files is immediately usable - no separate
+        script execution needed. Updates model/schema.sql symlink to point
+        to the new version.
 
         This method is used by:
         - init-project: Generate initial schema-0.0.0.sql after database setup
@@ -239,32 +244,33 @@ class Database:
             model_dir = Path("/project/model")
             schema_path = database._generate_schema_sql("0.0.0", model_dir)
             # → Creates model/schema-0.0.0.sql
-            # → Creates model/metadata-0.0.0.sql
+            # → Creates model/data-0.0.0.sql
             # → Creates symlink model/schema.sql → schema-0.0.0.sql
             # → Returns Path("/project/model/schema-0.0.0.sql")
 
             # During deploy-to-prod - save production schema
             schema_path = database._generate_schema_sql("1.3.4", model_dir)
             # → Creates model/schema-1.3.4.sql
-            # → Creates model/metadata-1.3.4.sql
+            # → Creates model/data-1.3.4.sql
             # → Updates symlink model/schema.sql → schema-1.3.4.sql
 
         File Structure Created:
             model/
-            ├── schema.sql          # Symlink to current version
-            ├── schema-0.0.0.sql    # Initial version (structure)
-            ├── metadata-0.0.0.sql  # Initial version (half_orm_meta data)
-            ├── schema-1.0.0.sql    # Production version (structure)
-            ├── metadata-1.0.0.sql  # Production version (half_orm_meta data)
-            ├── schema-1.3.4.sql    # Latest production version (current)
-            ├── metadata-1.3.4.sql  # Latest production version (current)
+            ├── schema.sql       # Symlink to current version
+            ├── schema-0.0.0.sql # Initial version (structure)
+            ├── data-0.0.0.sql   # Initial version (half_orm_meta + app data)
+            ├── schema-1.0.0.sql # Production version (structure)
+            ├── data-1.0.0.sql   # Production version (half_orm_meta + app data)
+            ├── schema-1.3.4.sql # Latest production version (current)
+            ├── data-1.3.4.sql   # Latest production version (current)
             └── ...
 
         Notes:
             - Uses pg_dump --schema-only for structure (no data)
-            - Uses pg_dump --data-only for metadata (only half_orm_meta tables)
+            - Uses pg_dump --data-only for data (all tables: half_orm_meta
+              bookkeeping and application data alike)
             - Symlink is relative (schema.sql → schema-X.Y.Z.sql)
-            - No symlink for metadata (version deduced from schema.sql)
+            - No symlink for data (version deduced from schema.sql)
             - Existing symlink is replaced atomically
             - Version format should be X.Y.Z (semantic versioning)
         """
@@ -329,25 +335,70 @@ class Database:
             if temp_schema_file.exists():
                 temp_schema_file.unlink()
 
-        # Generate metadata dump (half_orm_meta data only)
-        # Keep only COPY statements to avoid version-specific SET commands
-        metadata_file = model_dir / f"metadata-{version}.sql"
-        temp_file = model_dir / f".metadata-{version}.sql.tmp"
+        self._generate_data_sql(version, model_dir)
+
+        # Create or update symlink
+        symlink_path = model_dir / "schema.sql"
+        symlink_target = f"schema-{version}.sql"  # Relative path
+
+        try:
+            # Remove existing symlink if it exists
+            if symlink_path.exists() or symlink_path.is_symlink():
+                symlink_path.unlink()
+
+            # Create new symlink (relative)
+            symlink_path.symlink_to(symlink_target)
+
+        except PermissionError as e:
+            raise PermissionError(
+                f"Permission denied: cannot create symlink in {model_dir}"
+            ) from e
+        except OSError as e:
+            raise OSError(
+                f"Failed to create symlink {symlink_path} → {symlink_target}: {e}"
+            ) from e
+
+        return schema_file
+
+    def _generate_data_sql(self, version: str, model_dir: Path) -> Path:
+        """
+        Generate model/data-{version}.sql: a full pg_dump --data-only
+        snapshot (half_orm_meta bookkeeping + all application data) for
+        the given version.
+
+        Extracted out of _generate_schema_sql() so it can also be called
+        standalone by the metadata->data migration (which needs to
+        backfill this file for a project's already-published current
+        version, without touching schema-{version}.sql or the symlink).
+
+        Args:
+            version: Version string (e.g., "1.3.4")
+            model_dir: Path to model/ directory where the file is written
+
+        Returns:
+            Path to the generated data file (model/data-{version}.sql)
+
+        Raises:
+            Exception: If pg_dump fails
+        """
+        data_file = model_dir / f"data-{version}.sql"
+        temp_file = model_dir / f".data-{version}.sql.tmp"
 
         try:
-            # Dump to temporary file
+            # Dump to temporary file (no --table= restriction: this file
+            # must be a complete, self-contained snapshot for a fresh
+            # instance - half_orm_meta bookkeeping and application data
+            # alike)
             self.execute_pg_command(
                 'pg_dump',
                 self.__name,
                 '--data-only',
-                '--table=half_orm_meta.database',
-                '--table=half_orm_meta.hop_release',
-                '--table=half_orm_meta.hop_release_issue',
                 '-f',
                 str(temp_file)
             )
 
             # Filter to keep only COPY blocks (COPY ... FROM stdin; ... \.)
+            # to avoid version-specific SET commands
             content = temp_file.read_text()
             filtered_lines = []
             in_copy_block = False
@@ -360,36 +411,14 @@ class Database:
                     in_copy_block = False
                     filtered_lines.append('')  # Empty line between blocks
 
-            metadata_file.write_text('\n'.join(filtered_lines))
+            data_file.write_text('\n'.join(filtered_lines))
         except Exception as e:
-            raise Exception(f"Failed to generate metadata SQL: {e}") from e
+            raise Exception(f"Failed to generate data SQL: {e}") from e
         finally:
-            # Clean up temporary file
             if temp_file.exists():
                 temp_file.unlink()
 
-        # Create or update symlink
-        symlink_path = model_dir / "schema.sql"
-        symlink_target = f"schema-{version}.sql"  # Relative path
-
-        try:
-            # Remove existing symlink if it exists
-            if symlink_path.exists() or symlink_path.is_symlink():
-                symlink_path.unlink()
-
-            # Create new symlink (relative)
-            symlink_path.symlink_to(symlink_target)
-
-        except PermissionError as e:
-            raise PermissionError(
-                f"Permission denied: cannot create symlink in {model_dir}"
-            ) from e
-        except OSError as e:
-            raise OSError(
-                f"Failed to create symlink {symlink_path} → {symlink_target}: {e}"
-            ) from e
-
-        return schema_file
+        return data_file
 
     @classmethod
     def _save_configuration(cls, database_name, connection_params):
@@ -632,13 +661,12 @@ class Database:
         """
         # Prepare environment variables for PostgreSQL commands
         env = os.environ.copy()
-        env['PGUSER'] = connection_params['user']
-        env['PGHOST'] = connection_params['host']
-        env['PGPORT'] = str(connection_params['port'])
-
-        # Set password if provided (use PGPASSWORD environment variable)
-        if connection_params.get('password'):
-            env['PGPASSWORD'] = connection_params['password']
+        pg_env_keys = {'user': 'PGUSER', 'host': 'PGHOST', 'port': 'PGPORT', 'password': 'PGPASSWORD'}
+        env.update({
+            pg_env_keys[k]: str(v)
+            for k, v in connection_params.items()
+            if k in pg_env_keys and v
+        })
 
         # Execute PostgreSQL command
         result = subprocess.run(
@@ -1101,9 +1129,11 @@ class Database:
         """
         Collect missing connection parameters interactively.
 
-        Takes partial connection parameters from CLI options and prompts
-        interactively for any missing or None values. Applies halfORM
-        standard defaults where appropriate.
+        Takes partial connection parameters from CLI options. Missing
+        user/password are prompted for interactively. Missing host/port
+        are resolved like any standard PostgreSQL client tool - from the
+        PGHOST/PGPORT environment variables, then localhost/5432 - never
+        prompted for.
 
         Args:
             database_name (str): PostgreSQL database name for context
@@ -1127,11 +1157,12 @@ class Database:
             EOFError: If input stream is closed during prompts
 
         Interactive Behavior:
-            - Only prompts for missing/None parameters
-            - Shows current defaults in prompts: "Host (localhost): "
+            - Only prompts for missing/None user/password
             - Uses getpass for secure password input
             - Allows empty input to accept defaults
             - Confirms production flag if True
+            - host/port are never prompted for (PGHOST/PGPORT env vars,
+              then localhost/5432)
 
         Examples:
             # Complete parameters provided - no prompts
@@ -1149,13 +1180,14 @@ class Database:
             # Prompts: "User (current_user): " and "Password: [hidden]"
             # Returns: {'host': 'localhost', 'port': 5432, 'user': 'prompted_user', 'password': 'prompted_pass', 'production': False}
 
-            # Only host provided - prompts for missing with defaults
+            # Host/port omitted - resolved from PGHOST/PGPORT (or
+            # localhost/5432), no prompt
             complete = Database._collect_connection_params(
                 "my_db",
-                {'host': 'prod.db.com'}
+                {'host': None, 'port': None, 'user': 'dev', 'password': 'secret'}
             )
-            # Prompts: "Port (5432): ", "User (current_user): ", "Password: "
-            # Returns: complete dict with provided host and prompted/default values
+            # Prompts: nothing for host/port
+            # Returns: complete dict with PGHOST/PGPORT-resolved host/port
 
             # Production flag confirmation
             complete = Database._collect_connection_params(
@@ -1189,29 +1221,23 @@ class Database:
             else:
                 complete_params['password'] = password_input
 
-        # Prompt for host if None
+        # Host/port are never prompted for interactively - like psql,
+        # pg_dump, createdb and every other standard PostgreSQL client
+        # tool, they fall back to the PGHOST/PGPORT environment variables
+        # (and finally to localhost/5432) rather than asking the user.
         if complete_params.get('host') is None:
-            host_input = input("Host (localhost): ").strip()
-            complete_params['host'] = host_input if host_input else 'localhost'
+            complete_params['host'] = os.environ.get('PGHOST', 'localhost')
 
-        # Prompt for port if None
         if complete_params.get('port') is None:
-            port_input = input("Port (5432): ").strip()
-            if port_input:
+            port_env = os.environ.get('PGPORT')
+            if port_env:
                 try:
-                    complete_params['port'] = int(port_input)
+                    complete_params['port'] = int(port_env)
                 except ValueError:
-                    raise ValueError(f"Invalid port number: {port_input}")
+                    raise ValueError(f"Invalid port number in PGPORT: {port_env}")
             else:
                 complete_params['port'] = 5432
 
-        # Apply defaults for still missing parameters (no prompts needed)
-        if complete_params.get('host') is None:
-            complete_params['host'] = 'localhost'
-
-        if complete_params.get('port') is None:
-            complete_params['port'] = 5432
-
         if complete_params.get('user') is None:
             complete_params['user'] = os.environ.get('USER', 'postgres')
 
@@ -1277,11 +1303,10 @@ class Database:
 
     def has_createdb_privilege(self) -> bool:
         """Check if the current PostgreSQL user has the CREATEDB privilege."""
-        params = self._get_connection_params()
-        result = self._execute_pg_command(
-            'postgres', params,
+        result = self.execute_pg_command(
             'psql', '-d', 'postgres', '-t', '-c',
-            "SELECT rolcreatedb FROM pg_roles WHERE rolname = current_user"
+            "SELECT rolcreatedb FROM pg_roles WHERE rolname = current_user",
+            database_name='postgres'
         )
         return result.stdout.strip().lower() == 't'
 
@@ -1294,14 +1319,13 @@ class Database:
         Returns:
             Number of connections terminated.
         """
-        params = self._get_connection_params()
         sql = (
             f"SELECT count(pg_terminate_backend(pid)) FROM pg_stat_activity "
             f"WHERE datname = '{self.__name}'"
         )
-        result = self._execute_pg_command(
-            'postgres', params,
-            'psql', '-d', 'postgres', '-t', '-c', sql
+        result = self.execute_pg_command(
+            'psql', '-d', 'postgres', '-t', '-c', sql,
+            database_name='postgres'
         )
         try:
             return int(result.stdout.strip())
@@ -1317,10 +1341,9 @@ class Database:
         Args:
             snapshot_name: Name for the new snapshot database.
         """
-        params = self._get_connection_params()
-        self._execute_pg_command(
-            'postgres', params,
-            'createdb', '-T', self.__name, snapshot_name
+        self.execute_pg_command(
+            'createdb', '-T', self.__name, snapshot_name,
+            database_name='postgres'
         )
 
     def drop_snapshot(self, snapshot_name: str) -> None:
@@ -1329,10 +1352,9 @@ class Database:
         Args:
             snapshot_name: Name of the snapshot database to drop.
         """
-        params = self._get_connection_params()
-        self._execute_pg_command(
-            'postgres', params,
-            'dropdb', '--if-exists', snapshot_name
+        self.execute_pg_command(
+            'dropdb', '--if-exists', snapshot_name,
+            database_name='postgres'
         )
 
     def restore_from_snapshot(self, snapshot_name: str) -> None:
@@ -1344,17 +1366,15 @@ class Database:
         Args:
             snapshot_name: Name of the snapshot database to restore from.
         """
-        params = self._get_connection_params()
-        self._execute_pg_command('postgres', params, 'dropdb', self.__name)
-        self._execute_pg_command('postgres', params, 'createdb', '-T', snapshot_name, self.__name)
+        self.execute_pg_command('dropdb', self.__name, database_name='postgres')
+        self.execute_pg_command('createdb', '-T', snapshot_name, self.__name, database_name='postgres')
 
     def list_snapshots(self) -> list:
         """Return snapshot names matching {db}_hop_snap_* pattern, sorted ascending."""
-        params = self._get_connection_params()
-        result = self._execute_pg_command(
-            'postgres', params,
+        result = self.execute_pg_command(
             'psql', '-d', 'postgres', '-t', '-c',
-            f"SELECT datname FROM pg_database WHERE datname LIKE '{self.__name}_hop_snap_%' ORDER BY datname"
+            f"SELECT datname FROM pg_database WHERE datname LIKE '{self.__name}_hop_snap_%' ORDER BY datname",
+            database_name='postgres'
         )
         return [line.strip() for line in result.stdout.splitlines() if line.strip()]