jetbase 0.7.0__py3-none-any.whl → 0.12.1__py3-none-any.whl

jetbase-0.12.1.dist-info/METADATA

@@ -0,0 +1,135 @@
+Metadata-Version: 2.4
+Name: jetbase
+Version: 0.12.1
+Summary: Jetbase is a Python database migration tool
+Author-email: jaz <jaz.allibhai@gmail.com>
+License-File: LICENSE
+Requires-Python: >=3.10
+Requires-Dist: packaging>=25.0
+Requires-Dist: rich>=12.2.0
+Requires-Dist: sqlalchemy>=2.0.10
+Requires-Dist: tomli>=2.0.2
+Requires-Dist: typer>=0.12.3
+Description-Content-Type: text/markdown
+
+# Welcome to Jetbase 🚀
+
+**Jetbase** is a simple, lightweight database migration tool for Python projects.
+
+Jetbase helps you manage database migrations in a simple, version-controlled way. Whether you're adding a new table, modifying columns, or need to undo a change, Jetbase makes it super easy!
+
+### Key Features ✨
+
+- **📦 Simple Setup** — Get started with just one command
+- **⬆️ Easy Upgrades** — Apply pending migrations with confidence
+- **⬇️ Safe Rollbacks** — Made a mistake? No problem, roll it back!
+- **📊 Clear Status** — Always know which migrations have been applied and which are pending
+- **🔒 Migration Locking** — Prevents conflicts when multiple processes try to migrate
+- **✅ Checksum Validation** — Detects if migration files have been modified
+- **🔄 Repeatable Migrations** — Support for migrations that run on every upgrade
+
+[📚 Full Documentation](https://jetbase-hq.github.io/jetbase/)
+
+## Quick Start 🏃‍♂️
+
+### Installation
+
+**Using pip:**
+```shell
+pip install jetbase
+```
+
+**Using uv:**
+```shell
+uv add jetbase
+```
+
+### Initialize Your Project
+
+```bash
+jetbase init
+cd jetbase
+```
+
+This creates a `jetbase/` directory with:
+
+- A `migrations/` folder for your SQL files
+- An `env.py` configuration file
+
+### Configure Your Database
+
+Edit `jetbase/env.py` with your database connection string (currently support for postgres and sqlite):
+
+**PostgreSQL example:**
+```python
+sqlalchemy_url = "postgresql+psycopg2://user:password@localhost:5432/mydb"
+```
+
+**SQLite example:**
+```python
+sqlalchemy_url = "sqlite:///mydb.db"
+```
+
+### Create Your First Migration
+
+```bash
+jetbase new "create users table"
+```
+
+This creates a new SQL file like `V20251225.120000__create_users_and_items_tables.sql`.
+
+> **Tip:**  
+> You can also create migrations manually by adding SQL files in the `jetbase/migrations` directory, using the `V<version>__<description>.sql` naming convention (e.g., `V1__add_users_table.sql`, `V2.4__add_users_table.sql`).
+
+
+### Write Your Migration
+
+Open the newly created file and add your SQL:
+
+```sql
+-- upgrade
+CREATE TABLE users (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL,
+    email VARCHAR(255) UNIQUE NOT NULL
+);
+
+CREATE TABLE items (
+    id SERIAL PRIMARY KEY,
+    name VARCHAR(100) NOT NULL
+);
+
+-- rollback
+DROP TABLE items;
+DROP TABLE users;
+```
+
+### Apply the Migration
+
+```bash
+jetbase upgrade
+```
+
+That's it! Your database is now up to date. 🎉
+
+> **Note:**  
+> Jetbase uses SQLAlchemy under the hood to manage database connections.  
+> For any database other than SQLite, you must install the appropriate Python database driver.  
+> For example, to use Jetbase with PostgreSQL:
+
+```bash
+pip install psycopg2
+```
+
+You can also use another compatible driver if you prefer (such as `asyncpg`, `pg8000`, etc.).
+
+## Supported Databases
+
+Jetbase currently supports:
+
+- ✅ PostgreSQL
+- ✅ SQLite
+
+## Need Help?
+
+Open an issue on GitHub!

jetbase-0.12.1.dist-info/RECORD

@@ -0,0 +1,39 @@
+jetbase/config.py,sha256=81mex8hZcbos7KRB5ywndeSdmi-fV-J-WFcdIyIw2vE,10225
+jetbase/constants.py,sha256=Erzv_eR4KaTW96qWvoYzqT5he69xHYjCe0zzx5vkZpE,535
+jetbase/enums.py,sha256=_dVhrfl2WYqQjwf_ydDGvU-qR5LxQgdJVObph6aNWaM,998
+jetbase/exceptions.py,sha256=N8_HloEfg4f28RjBO4ems2HRDSfxR9c10_6F25hvrt4,2227
+jetbase/models.py,sha256=pIefNCinOuV2pPo2Mdtl_UbPuE7o7aXzu0ruP-bbIfI,1363
+jetbase/cli/main.py,sha256=64dM71Mgofd1Mhv2gTdr54wnSWh8gfJIWbChwG8zKCE,5882
+jetbase/commands/current.py,sha256=jXDxZ54hmEOgWpWLS474wCaBfPynPcyq6Qqm6efFBUs,735
+jetbase/commands/fix_checksums.py,sha256=pi5nLSR1vHzYKZn8ftX2-lEinctHqrgHo_FzPjkVfts,6330
+jetbase/commands/fix_files.py,sha256=aSorsu6bZrq_kLX14OrxDaee6KoEICjBMMoO832iQpQ,4785
+jetbase/commands/history.py,sha256=P-BlODZxcixjsawMT0JHi_FVRAeyZwPLiN0UQy5oN9M,1922
+jetbase/commands/init.py,sha256=LmFMkcF7zQbi3GWekgEy9Vb3_vTorrUkqOUgvAT1_qw,902
+jetbase/commands/lock_status.py,sha256=yu3AxEkeaHua_5ydclOMU36FW0J9Kacs05lbmSrqQGA,838
+jetbase/commands/new.py,sha256=6mxeP8yVDcXJSIBvnQgOqURRwANlNtsWT_77qE0z_NU,2280
+jetbase/commands/rollback.py,sha256=PZclqfvHCyrXG4wyDmco9O3o9PCjHApYjWcEG73N73c,6176
+jetbase/commands/status.py,sha256=5I_1gjmPShTHlTVUvvl2v2LJION5pGryfXYErybzFJ8,7307
+jetbase/commands/unlock.py,sha256=sM0YJJ6BfYgAy-W4jhdhGBcwtM-JMzN5uTfc8FK3ApQ,835
+jetbase/commands/upgrade.py,sha256=Vna0OviJHa6ge94cyJQbMkah3PvFPL0fraA2vProVqg,8998
+jetbase/commands/validators.py,sha256=keWjDcuO5wHOSb76BwJxj_M8Dthz3ZMaP3Td5cg5bB8,1366
+jetbase/database/connection.py,sha256=v3082NzzBQnd4vq-X6M4oXROPNtNI1r5iNwhuPZIEFg,1433
+jetbase/database/queries/base.py,sha256=f00vJRNGWaACVOJ2283Oh1G1LLc_eHxI1A-SABWwYo8,11775
+jetbase/database/queries/default_queries.py,sha256=7RzPMhgEK8_-In86s3HQN7Na-mY0zeydwLeyjX9v2tU,5257
+jetbase/database/queries/postgres.py,sha256=D6yNlIfHT4s4GZIe7tAQfXvCeOVu2NxARctWsehrwfI,438
+jetbase/database/queries/query_loader.py,sha256=VwvsAQVrpe44cJQFqVWqzVbXB9yWYTQ0i0elkiOapBo,2641
+jetbase/database/queries/sqlite.py,sha256=3l1RBn9B363w-bslcutwQOAFpgSUJdeqSkHpYZZ0S4A,5641
+jetbase/engine/checksum.py,sha256=Q59s_9dkk4uWHUyG8WZcoTvRr9wRdSCeaDKma5i2kw4,704
+jetbase/engine/dry_run.py,sha256=Yz9qpnv1YfA0ZAjCP_HEtCaguuGTo-JqzmnyinjMJQI,3845
+jetbase/engine/file_parser.py,sha256=cWPUYa9WolFXsKMdr4NT3Sdf70ePG6bt2sXs4PEzrUk,10299
+jetbase/engine/formatters.py,sha256=fG91mN0ymYK90upOCwpg43g8LJ3o7inUec8mkBPMzAo,1895
+jetbase/engine/lock.py,sha256=JCZxb9r26RN2OUJl0tCR6xsOQIex_nACcR0_Lgprp38,1901
+jetbase/engine/repeatable.py,sha256=WyN46LyHiNxAdjLFlqye2w2I-mKXMGW7GuzdfpITSv8,4614
+jetbase/engine/validation.py,sha256=tZg3X6LeNHl-cD2tmazjmQDS0mwdkzWVnko0rSn43-Y,9527
+jetbase/engine/version.py,sha256=JpSnHiLiwiUsWIqsIEmeSVbhNqkibVpIYv7Pl6lioIM,5388
+jetbase/repositories/lock_repo.py,sha256=foQ3zX38UTxXg4sH1Gh4NJ5xDqBygeueaG8DevElMeM,3940
+jetbase/repositories/migrations_repo.py,sha256=23MO2KIFvvZ75xqxcllx9Gon6PDI5kvCDNL-k77bH7U,15459
+jetbase-0.12.1.dist-info/METADATA,sha256=vYI37rlngvWZFe24sx8xK06vrDTnFlZvHcLkJDJa00s,3334
+jetbase-0.12.1.dist-info/WHEEL,sha256=WLgqFyCfm_KASv4WHyYy0P3pM_m7J5L9k2skdKLirC8,87
+jetbase-0.12.1.dist-info/entry_points.txt,sha256=-Pe7A0r8aGF-6C14hB0Ck8aEuszuH5pdadt5OWSiWwA,50
+jetbase-0.12.1.dist-info/licenses/LICENSE,sha256=hyssQNKtnK32aFCk8mVR406ysMtGNP6_dZCig8zBk4Q,1065
+jetbase-0.12.1.dist-info/RECORD,,

{jetbase-0.7.0.dist-info → jetbase-0.12.1.dist-info}/WHEEL

@@ -1,4 +1,4 @@
 Wheel-Version: 1.0
-Generator: hatchling 1.27.0
+Generator: hatchling 1.28.0
 Root-Is-Purelib: true
 Tag: py3-none-any

jetbase/core/dry_run.py

@@ -1,38 +0,0 @@
-import os
-
-from jetbase.core.file_parser import parse_rollback_statements, parse_upgrade_statements
-from jetbase.enums import MigrationOperationType
-
-
-def process_dry_run(
-    version_to_filepath: dict[str, str], migration_operation: MigrationOperationType
-) -> None:
-    print("\nJETBASE - Dry Run Mode")
-    print("No SQL will be executed. This is a preview of what would happen.")
-    print("----------------------------------------\n\n")
-
-    for version, file_path in version_to_filepath.items():
-        if migration_operation == MigrationOperationType.UPGRADE:
-            sql_statements: list[str] = parse_upgrade_statements(
-                file_path=file_path, dry_run=True
-            )
-        elif migration_operation == MigrationOperationType.ROLLBACK:
-            sql_statements: list[str] = parse_rollback_statements(
-                file_path=file_path, dry_run=True
-            )
-        else:
-            raise NotImplementedError(
-                f"Dry run not implemented for migration operation: {migration_operation}"
-            )
-
-        filename: str = os.path.basename(file_path)
-
-        num_sql_statements: int = len(sql_statements)
-
-        print(
-            f"\nSQL Preview for {filename} ({num_sql_statements} {'statements' if num_sql_statements != 1 else 'statement'})"
-        )
-        for statement in sql_statements:
-            print("\n")
-            print(statement)
-        print("----------------------------------------\n")

jetbase/core/file_parser.py

@@ -1,199 +0,0 @@
-import re
-
-from jetbase.enums import MigrationOperationType
-
-
-def parse_upgrade_statements(file_path: str, dry_run: bool = False) -> list[str]:
-    statements = []
-    current_statement = []
-
-    with open(file_path, "r") as file:
-        for line in file:
-            if not dry_run:
-                line = line.strip()
-            else:
-                line = line.rstrip()
-
-            if (
-                line.strip().startswith("--")
-                and line[2:].strip().lower() == MigrationOperationType.ROLLBACK.value
-            ):
-                break
-
-            if not line or line.strip().startswith("--"):
-                continue
-            current_statement.append(line)
-
-            if line.strip().endswith(";"):
-                if not dry_run:
-                    statement = " ".join(current_statement)
-                else:
-                    statement = "\n".join(current_statement)
-                statement = statement.rstrip(";").strip()
-                if statement:
-                    statements.append(statement)
-                current_statement = []
-
-    return statements
-
-
-def parse_rollback_statements(file_path: str, dry_run: bool = False) -> list[str]:
-    statements = []
-    current_statement = []
-    in_rollback_section = False
-
-    with open(file_path, "r") as file:
-        for line in file:
-            if not dry_run:
-                line = line.strip()
-            else:
-                line = line.rstrip()
-
-            if not in_rollback_section:
-                if (
-                    line.strip().startswith("--")
-                    and line[2:].strip().lower()
-                    == MigrationOperationType.ROLLBACK.value
-                ):
-                    in_rollback_section = True
-                else:
-                    continue
-
-            if in_rollback_section:
-                if not line or line.strip().startswith("--"):
-                    continue
-                current_statement.append(line)
-
-                if line.strip().endswith(";"):
-                    if not dry_run:
-                        statement = " ".join(current_statement)
-                    else:
-                        statement = "\n".join(current_statement)
-                    statement = statement.rstrip(";").strip()
-                    if statement:
-                        statements.append(statement)
-                    current_statement = []
-
-    return statements
-
-
-def is_filename_format_valid(filename: str) -> bool:
-    """
-    Validates if a filename follows the expected migration file naming convention.
-    A valid filename must:
-    - Start with "V"
-    - Have a valid version number following "V"
-    - Contain "__" (double underscore)
-    - End with ".sql"
-    - Have a valid version number extractable from the filename
-    Args:
-        filename (str): The filename to validate.
-    Returns:
-        bool: True if the filename meets all validation criteria, False otherwise.
-    Example:
-        >>> is_valid_filename_format("V1__initial_migration.sql")
-        True
-        >>> is_valid_filename_format("migration.sql")
-        False
-    """
-    if not filename.endswith(".sql"):
-        return False
-    if not filename.startswith("V"):
-        return False
-    if "__" not in filename:
-        return False
-    description: str = _get_raw_description_from_filename(filename=filename)
-    if len(description.strip()) == 0:
-        return False
-    raw_version: str = _get_version_from_filename(filename=filename)
-    if not _is_valid_version(version=raw_version):
-        return False
-    return True
-
-
-def get_description_from_filename(filename: str) -> str:
-    """
-    Extract and format the description from a migration filename.
-
-    Args:
-        filename: The migration filename (e.g., "V1_2_0__add_feature.sql")
-
-    Returns:
-        str: The formatted description string (e.g., "add feature")
-    """
-
-    raw_description: str = _get_raw_description_from_filename(filename=filename)
-    formatted_description: str = raw_description.replace("_", " ")
-    return formatted_description
-
-
-def is_filename_length_valid(filename: str, max_length: int = 512) -> bool:
-    """
-    Check if the filename length is within the specified maximum length.
-
-    Args:
-        filename: The migration filename to check.
-        max_length: The maximum allowed length for the filename.
-
-    Returns:
-        bool: True if the filename length is within the maximum length, False otherwise.
-    """
-    return len(filename) <= max_length
-
-
-def _get_version_from_filename(filename: str) -> str:
-    """
-    Extract the version string from a migration filename.
-
-    Args:
-        filename: The migration filename (e.g., "V1_2_0__add_feature.sql")
-
-    Returns:
-        str: The extracted version string (e.g., "1_2_0")
-    """
-
-    version: str = filename[1 : filename.index("__")]
-    return version
-
-
-def _get_raw_description_from_filename(filename: str) -> str:
-    """
-    Extract the description string from a migration filename.
-
-    Args:
-        filename: The migration filename (e.g., "V1_2_0__add_feature.sql")
-
-    Returns:
-        str: The extracted description string (e.g., "add_feature")
-    """
-
-    description: str = filename[
-        filename.index("__") + 2 : filename.index(".sql")
-    ].strip()
-    return description
-
-
-def _is_valid_version(version: str) -> bool:
-    """
-    Validate that a version string follows the correct format.
-
-    Rules:
-    - Must start and end with a number
-    - Can be any length (1 or greater)
-    - Can contain periods (.) or underscores (_) between numbers
-
-    Valid examples: "1", "1.2", "1_2", "1.2.3", "1_2_3", "10.20.30"
-    Invalid examples: ".1", "1.", "_1", "1_", "1..2", "1__2", "abc", ""
-
-    Args:
-        version: The version string to validate
-
-    Returns:
-        bool: True if version is valid, False otherwise
-    """
-    if not version:
-        return False
-
-    # Pattern: starts with digit, ends with digit, can have periods/underscores between digits
-    pattern = r"^\d+([._]\d+)*$"
-    return bool(re.match(pattern, version))

jetbase/core/initialize.py

@@ -1,33 +0,0 @@
-from pathlib import Path
-
-from jetbase.constants import BASE_DIR, CONFIG_FILE, CONFIG_FILE_CONTENT, MIGRATIONS_DIR
-
-
-def create_directory_structure(base_path: str) -> None:
-    """
-    Create the basic directory structure for a new Jetbase project.
-
-    This function creates:
-    - A migrations directory
-    - A config file with default content
-
-    After creating the structure, it prints a confirmation message.
-
-    Args:
-        base_path (str): The base path where the Jetbase project structure will be created
-
-    Returns:
-        None
-    """
-    migrations_dir: Path = Path(base_path) / MIGRATIONS_DIR
-    migrations_dir.mkdir(parents=True, exist_ok=True)
-
-    config_path: Path = Path(base_path) / CONFIG_FILE
-    with open(config_path, "w") as f:
-        f.write(CONFIG_FILE_CONTENT)
-
-    print(f"Initialized Jetbase project in {Path(base_path).absolute()}")
-
-
-def initialize_cmd() -> None:
-    create_directory_structure(base_path=BASE_DIR)

jetbase/core/repository.py

@@ -1,169 +0,0 @@
-from sqlalchemy import Engine, Result, create_engine, text
-
-from jetbase.config import get_sqlalchemy_url
-from jetbase.core.file_parser import get_description_from_filename
-from jetbase.enums import MigrationOperationType
-from jetbase.queries import (
-    CHECK_IF_MIGRATIONS_TABLE_EXISTS_QUERY,
-    CHECK_IF_VERSION_EXISTS_QUERY,
-    CREATE_MIGRATIONS_TABLE_STMT,
-    DELETE_VERSION_STMT,
-    INSERT_VERSION_STMT,
-    LATEST_VERSION_QUERY,
-    LATEST_VERSIONS_BY_STARTING_VERSION_QUERY,
-    LATEST_VERSIONS_QUERY,
-)
-
-
-def get_last_updated_version() -> str | None:
-    """
-    Retrieves the latest version from the database.
-    This function connects to the database, executes a query to get the most recent version,
-    and returns that version as a string.
-    Returns:
-        str | None: The latest version string if available, None if no version was found.
-    """
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-
-    with engine.begin() as connection:
-        result: Result[tuple[str]] = connection.execute(LATEST_VERSION_QUERY)
-        latest_version: str | None = result.scalar()
-    if not latest_version:
-        return None
-    return latest_version
-
-
-def create_migrations_table_if_not_exists() -> None:
-    """
-    Creates the migrations table in the database
-    if it does not already exist.
-    Returns:
-        None
-    """
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-    with engine.begin() as connection:
-        connection.execute(statement=CREATE_MIGRATIONS_TABLE_STMT)
-
-
-def run_migration(
-    sql_statements: list[str],
-    version: str,
-    migration_operation: MigrationOperationType,
-    filename: str | None = None,
-) -> None:
-    """
-    Execute a database migration by running SQL statements and recording the migration version.
-    Args:
-        sql_statements (list[str]): List of SQL statements to execute as part of the migration
-        version (str): Version identifier to record after successful migration
-    Returns:
-        None
-    """
-
-    if migration_operation == MigrationOperationType.UPGRADE and filename is None:
-        raise ValueError("Filename must be provided for upgrade migrations.")
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-
-    with engine.begin() as connection:
-        for statement in sql_statements:
-            connection.execute(text(statement))
-
-        if migration_operation == MigrationOperationType.UPGRADE:
-            assert filename is not None
-            description: str = get_description_from_filename(filename=filename)
-            connection.execute(
-                statement=INSERT_VERSION_STMT,
-                parameters={
-                    "version": version,
-                    "description": description,
-                    "filename": filename,
-                },
-            )
-
-        elif migration_operation == MigrationOperationType.ROLLBACK:
-            connection.execute(
-                statement=DELETE_VERSION_STMT, parameters={"version": version}
-            )
-
-
-def get_latest_versions(limit: int) -> list[str]:
-    """
-    Retrieve the latest N migration versions from the database.
-    Args:
-        limit (int): The number of latest versions to retrieve
-    Returns:
-        list[str]: A list of the latest migration version strings
-    """
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-    latest_versions: list[str] = []
-
-    with engine.begin() as connection:
-        result: Result[tuple[str]] = connection.execute(
-            statement=LATEST_VERSIONS_QUERY,
-            parameters={"limit": limit},
-        )
-        latest_versions: list[str] = [row[0] for row in result.fetchall()]
-
-    return latest_versions
-
-
-def get_latest_versions_by_starting_version(
-    starting_version: str,
-) -> list[str]:
-    """
-    Retrieve the latest N migration versions from the database,
-    starting from a specific version.
-    Args:
-        starting_version (str): The version to start retrieving from
-        limit (int): The number of latest versions to retrieve
-    Returns:
-        list[str]: A list of the latest migration version strings
-    """
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-    latest_versions: list[str] = []
-    starting_version = starting_version
-
-    with engine.begin() as connection:
-        version_exists_result: Result[tuple[int]] = connection.execute(
-            statement=CHECK_IF_VERSION_EXISTS_QUERY,
-            parameters={"version": starting_version},
-        )
-        version_exists: int = version_exists_result.scalar_one()
-
-        if version_exists == 0:
-            raise ValueError(
-                f"'{starting_version}' has not been applied yet or does not exist."
-            )
-
-        latest_versions_result: Result[tuple[str]] = connection.execute(
-            statement=LATEST_VERSIONS_BY_STARTING_VERSION_QUERY,
-            parameters={"starting_version": starting_version},
-        )
-        latest_versions: list[str] = [
-            row[0] for row in latest_versions_result.fetchall()
-        ]
-
-    return latest_versions
-
-
-def migrations_table_exists() -> bool:
-    """
-    Check if the jetbase_migrations table exists in the database.
-    Returns:
-        bool: True if the jetbase_migrations table exists, False otherwise.
-    """
-
-    engine: Engine = create_engine(url=get_sqlalchemy_url())
-
-    with engine.begin() as connection:
-        result: Result[tuple[bool]] = connection.execute(
-            statement=CHECK_IF_MIGRATIONS_TABLE_EXISTS_QUERY
-        )
-        table_exists: bool = result.scalar_one()
-
-    return table_exists

jetbase/core/rollback.py

@@ -1,67 +0,0 @@
-import os
-
-from jetbase.core.dry_run import process_dry_run
-from jetbase.core.file_parser import parse_rollback_statements
-from jetbase.core.repository import (
-    get_latest_versions,
-    get_latest_versions_by_starting_version,
-    migrations_table_exists,
-    run_migration,
-)
-from jetbase.core.version import get_migration_filepaths_by_version
-from jetbase.enums import MigrationOperationType
-
-
-def rollback_cmd(
-    count: int | None = None, to_version: str | None = None, dry_run: bool = False
-) -> None:
-    table_exists: bool = migrations_table_exists()
-    if not table_exists:
-        print("No migrations have been applied; nothing to rollback.")
-        return
-
-    if count is not None and to_version is not None:
-        raise ValueError(
-            "Cannot specify both 'count' and 'to_version' for rollback. "
-            "Select only one, or do not specify either to rollback the last migration."
-        )
-    if count is None and to_version is None:
-        count = 1
-
-    latest_migration_versions: list[str] = []
-    if count:
-        latest_migration_versions = get_latest_versions(limit=count)
-    elif to_version:
-        latest_migration_versions = get_latest_versions_by_starting_version(
-            starting_version=to_version
-        )
-
-    if not latest_migration_versions:
-        print("No migrations have been applied; nothing to rollback.")
-        return
-
-    versions_to_rollback: dict[str, str] = get_migration_filepaths_by_version(
-        directory=os.path.join(os.getcwd(), "migrations"),
-        version_to_start_from=latest_migration_versions[-1],
-        end_version=latest_migration_versions[0],
-    )
-
-    versions_to_rollback: dict[str, str] = dict(reversed(versions_to_rollback.items()))
-
-    if not dry_run:
-        for version, file_path in versions_to_rollback.items():
-            sql_statements: list[str] = parse_rollback_statements(file_path=file_path)
-            run_migration(
-                sql_statements=sql_statements,
-                version=version,
-                migration_operation=MigrationOperationType.ROLLBACK,
-            )
-            filename: str = os.path.basename(file_path)
-
-            print(f"Rollback applied successfully: {filename}")
-
-    else:
-        process_dry_run(
-            version_to_filepath=versions_to_rollback,
-            migration_operation=MigrationOperationType.ROLLBACK,
-        )