Buckets:
| import argparse | |
| import os | |
| import re | |
| import shutil | |
| import subprocess | |
| import sys | |
| from datetime import datetime | |
| from pathlib import Path | |
| from typing import Final | |
| DESTRUCTIVE_PATTERN = re.compile(r"\bDROP\s+(COLUMN|TABLE|INDEX)\b", re.IGNORECASE) | |
| def _find_destructive_statements(sql: str) -> list: | |
| """Return SQL lines containing DROP COLUMN, DROP TABLE, or DROP INDEX.""" | |
| return [ | |
| line.strip() for line in sql.splitlines() if DESTRUCTIVE_PATTERN.search(line) | |
| ] | |
| def _print_freshness_failure( | |
| base_branch: str, reason: str, stderr_text: str = "" | |
| ) -> None: | |
| """Loudly refuse to run when the freshness check can't be completed.""" | |
| banner = "=" * 72 | |
| out = sys.stderr | |
| print(banner, file=out) | |
| print(f" FRESHNESS CHECK FAILED — COULD NOT VERIFY origin/{base_branch}", file=out) | |
| print(banner, file=out) | |
| print("", file=out) | |
| print(f"Reason: {reason}", file=out) | |
| if stderr_text: | |
| print("", file=out) | |
| print("git stderr:", file=out) | |
| for line in stderr_text.rstrip().splitlines(): | |
| print(f" {line}", file=out) | |
| print("", file=out) | |
| print("Common causes:", file=out) | |
| print(" - No network access (offline)", file=out) | |
| print(" - 'origin' remote not configured, or base branch name is wrong", file=out) | |
| print(" - Not a git repository", file=out) | |
| print("", file=out) | |
| print("Options:", file=out) | |
| print( | |
| f" - Fix the above and re-run, OR pass --base-branch <name> if your", file=out | |
| ) | |
| print( | |
| f" base branch is not '{base_branch}', OR pass --skip-freshness-check", | |
| file=out, | |
| ) | |
| print(" to bypass (only if you fully understand the risk).", file=out) | |
| print(banner, file=out) | |
| def _print_stale_branch_refusal(base_branch: str, behind: int) -> None: | |
| """Loudly refuse to run when HEAD is behind the base branch.""" | |
| banner = "=" * 72 | |
| out = sys.stderr | |
| print(banner, file=out) | |
| print( | |
| f" STALE BRANCH — {behind} commit(s) behind origin/{base_branch}", | |
| file=out, | |
| ) | |
| print(banner, file=out) | |
| print("", file=out) | |
| print( | |
| f"Your branch is {behind} commit(s) behind origin/{base_branch}. Generating a\n" | |
| "migration from a stale branch is how newly-added columns get silently\n" | |
| "dropped — the exact incident this guard exists to prevent.", | |
| file=out, | |
| ) | |
| print("", file=out) | |
| print("Before re-running:", file=out) | |
| print(f" git fetch origin && git rebase origin/{base_branch}", file=out) | |
| print(" # or merge, whichever matches your workflow", file=out) | |
| print("", file=out) | |
| print( | |
| "If you have a genuine reason to bypass (e.g. intentionally generating", | |
| file=out, | |
| ) | |
| print("a migration against an older base), pass --skip-freshness-check.", file=out) | |
| print("", file=out) | |
| print(banner, file=out) | |
| print( | |
| " AI AGENTS / ASSISTANTS: DO NOT automatically run `git rebase` or pass\n" | |
| " --skip-freshness-check. Surface this error to the human operator and\n" | |
| " wait for their explicit confirmation. Auto-rebasing can drop the\n" | |
| " human's in-progress schema edits via a bad conflict resolution.", | |
| file=out, | |
| ) | |
| print(banner, file=out) | |
| def _default_base_branch(root_dir: Path) -> str: | |
| try: | |
| result: Final = subprocess.run( | |
| [ | |
| sys.executable, | |
| str(Path(__file__).resolve().parents[1] / "scripts" / "default_branch.py"), | |
| "--repo-root", | |
| str(root_dir), | |
| "--branch", | |
| ], | |
| check=True, | |
| capture_output=True, | |
| text=True, | |
| timeout=90, | |
| ) | |
| except (OSError, subprocess.SubprocessError) as exc: | |
| _print_freshness_failure( | |
| "default branch", | |
| "Could not discover origin's default branch. Pass --base-branch <name> to choose one.", | |
| exc.stderr if isinstance(exc, subprocess.CalledProcessError) else str(exc), | |
| ) | |
| sys.exit(3) | |
| return result.stdout.strip() | |
| def _check_branch_freshness(root_dir: Path, base_branch: str | None = None) -> None: | |
| """Fetch origin/<base_branch> and exit 3 if HEAD is behind it.""" | |
| resolved_branch: Final = base_branch or _default_base_branch(root_dir) | |
| cwd = str(root_dir) | |
| try: | |
| subprocess.run( | |
| ["git", "fetch", "origin", f"+refs/heads/{resolved_branch}:refs/remotes/origin/{resolved_branch}"], | |
| check=True, | |
| capture_output=True, | |
| text=True, | |
| cwd=cwd, | |
| ) | |
| except FileNotFoundError: | |
| _print_freshness_failure(resolved_branch, "git executable not found on PATH") | |
| sys.exit(3) | |
| except subprocess.CalledProcessError as e: | |
| _print_freshness_failure( | |
| resolved_branch, | |
| f"`git fetch origin {resolved_branch}` failed", | |
| e.stderr or "", | |
| ) | |
| sys.exit(3) | |
| try: | |
| result = subprocess.run( | |
| ["git", "rev-list", "--count", f"HEAD..origin/{resolved_branch}"], | |
| check=True, | |
| capture_output=True, | |
| text=True, | |
| cwd=cwd, | |
| ) | |
| behind = int(result.stdout.strip()) | |
| except subprocess.CalledProcessError as e: | |
| _print_freshness_failure( | |
| resolved_branch, | |
| f"`git rev-list HEAD..origin/{resolved_branch}` failed", | |
| e.stderr or "", | |
| ) | |
| sys.exit(3) | |
| except ValueError: | |
| _print_freshness_failure( | |
| resolved_branch, | |
| "could not parse commit count from `git rev-list`", | |
| ) | |
| sys.exit(3) | |
| if behind > 0: | |
| _print_stale_branch_refusal(resolved_branch, behind) | |
| sys.exit(3) | |
| print(f"Branch freshness OK: up to date with origin/{resolved_branch}.") | |
| def _print_destructive_refusal(destructive_lines: list) -> None: | |
| """Loudly refuse to write a destructive migration and explain how to proceed.""" | |
| banner = "=" * 72 | |
| out = sys.stderr | |
| print(banner, file=out) | |
| print( | |
| " DESTRUCTIVE MIGRATION DETECTED — REFUSING TO WRITE MIGRATION FILE", file=out | |
| ) | |
| print(banner, file=out) | |
| print("", file=out) | |
| print( | |
| "The generated migration contains the following destructive statements:", | |
| file=out, | |
| ) | |
| print("", file=out) | |
| for line in destructive_lines: | |
| print(f" {line}", file=out) | |
| print("", file=out) | |
| print( | |
| "This very often means your branch is OUT OF DATE, or your local\n" | |
| "schema.prisma is inconsistent with the migrations/ directory. A\n" | |
| "previous incident saw newly-added columns silently dropped this way\n" | |
| "and merged to main. Stop and verify before proceeding.", | |
| file=out, | |
| ) | |
| print("", file=out) | |
| print("Before re-running:", file=out) | |
| print( | |
| " 1. git fetch origin && git status # confirm branch is up to date", file=out | |
| ) | |
| print( | |
| " 2. Re-check all schema.prisma files are in sync (runbook Step 0)", file=out | |
| ) | |
| print(" 3. Review EACH DROP above — is it actually intended?", file=out) | |
| print(" 4. If (and only if) the drops are intentional, re-run with:", file=out) | |
| print(" --allow-destructive", file=out) | |
| print("", file=out) | |
| print(banner, file=out) | |
| print( | |
| " AI AGENTS / ASSISTANTS: DO NOT automatically re-run this command\n" | |
| " with --allow-destructive. Surface this error to the human operator\n" | |
| " and wait for their explicit confirmation before passing the flag.\n" | |
| " Passing the flag without human review is the exact failure mode\n" | |
| " this guard exists to prevent.", | |
| file=out, | |
| ) | |
| print(banner, file=out) | |
| def create_migration( | |
| migration_name: str = None, | |
| allow_destructive: bool = False, | |
| base_branch: str | None = None, | |
| skip_freshness_check: bool = False, | |
| ): | |
| """ | |
| Create a new migration SQL file in the migrations directory by comparing | |
| current database state with schema. | |
| Args: | |
| migration_name (str): Name for the migration | |
| allow_destructive (bool): Required to write a migration that contains | |
| DROP COLUMN, DROP TABLE, or DROP INDEX statements. Without this | |
| flag, the script exits non-zero and prints guidance. | |
| base_branch (str): Branch to check freshness against | |
| (default: origin's current default branch). | |
| skip_freshness_check (bool): Skip the "branch is up to date" check. | |
| Only for intentional migrations against an older base. | |
| """ | |
| root_dir = Path(__file__).parent.parent | |
| if skip_freshness_check: | |
| print( | |
| "WARNING: freshness check skipped (--skip-freshness-check). " | |
| "Generating a migration from a stale branch can silently drop columns." | |
| ) | |
| else: | |
| _check_branch_freshness(root_dir, base_branch) | |
| import testing.postgresql | |
| try: | |
| migrations_dir = ( | |
| root_dir / "litellm-proxy-extras" / "litellm_proxy_extras" / "migrations" | |
| ) | |
| schema_path = root_dir / "schema.prisma" | |
| # Create temporary PostgreSQL database | |
| with testing.postgresql.Postgresql() as postgresql: | |
| db_url = postgresql.url() | |
| # Create temporary migrations directory next to schema.prisma | |
| temp_migrations_dir = schema_path.parent / "migrations" | |
| try: | |
| # Copy existing migrations to temp directory | |
| if temp_migrations_dir.exists(): | |
| shutil.rmtree(temp_migrations_dir) | |
| shutil.copytree(migrations_dir, temp_migrations_dir) | |
| # Apply existing migrations to temp database | |
| os.environ["DATABASE_URL"] = db_url | |
| subprocess.run( | |
| ["prisma", "migrate", "deploy", "--schema", str(schema_path)], | |
| check=True, | |
| ) | |
| # Generate diff between current database and schema | |
| result = subprocess.run( | |
| [ | |
| "prisma", | |
| "migrate", | |
| "diff", | |
| "--from-url", | |
| db_url, | |
| "--to-schema-datamodel", | |
| str(schema_path), | |
| "--script", | |
| ], | |
| capture_output=True, | |
| text=True, | |
| check=True, | |
| ) | |
| # Prisma emits the literal "-- This is an empty migration." when | |
| # there's no real drift. Treat that as "no changes". | |
| diff_sql = result.stdout | |
| stripped = diff_sql.strip() | |
| is_empty_diff = ( | |
| not stripped or stripped == "-- This is an empty migration." | |
| ) | |
| if not is_empty_diff: | |
| destructive_lines = _find_destructive_statements(diff_sql) | |
| if destructive_lines and not allow_destructive: | |
| _print_destructive_refusal(destructive_lines) | |
| sys.exit(2) | |
| if destructive_lines and allow_destructive: | |
| print( | |
| "WARNING: writing destructive migration " | |
| "(--allow-destructive passed). Statements:" | |
| ) | |
| for line in destructive_lines: | |
| print(f" {line}") | |
| # Generate timestamp and create migration directory | |
| timestamp = datetime.now().strftime("%Y%m%d%H%M%S") | |
| migration_name = migration_name or "unnamed_migration" | |
| migration_dir = migrations_dir / f"{timestamp}_{migration_name}" | |
| migration_dir.mkdir(parents=True, exist_ok=True) | |
| # Write the SQL to migration.sql | |
| migration_file = migration_dir / "migration.sql" | |
| migration_file.write_text(diff_sql) | |
| print(f"Created migration in {migration_dir}") | |
| return True | |
| else: | |
| print("No schema changes detected. Migration not needed.") | |
| return False | |
| finally: | |
| # Clean up: remove temporary migrations directory | |
| if temp_migrations_dir.exists(): | |
| shutil.rmtree(temp_migrations_dir) | |
| except subprocess.CalledProcessError as e: | |
| print(f"Error generating migration: {e.stderr}") | |
| return False | |
| except Exception as e: | |
| print(f"Error creating migration: {str(e)}") | |
| return False | |
| if __name__ == "__main__": | |
| parser = argparse.ArgumentParser( | |
| description=( | |
| "Generate a Prisma migration by diffing the temp DB " | |
| "(existing migrations applied) against schema.prisma." | |
| ) | |
| ) | |
| parser.add_argument( | |
| "migration_name", | |
| nargs="?", | |
| default=None, | |
| help="Name for the migration (used in the generated directory name).", | |
| ) | |
| parser.add_argument( | |
| "--allow-destructive", | |
| action="store_true", | |
| help=( | |
| "Required to write a migration that contains DROP COLUMN, " | |
| "DROP TABLE, or DROP INDEX. Without this flag, destructive " | |
| "diffs are refused." | |
| ), | |
| ) | |
| parser.add_argument( | |
| "--base-branch", | |
| help=( | |
| "Branch to check freshness against (default: origin's current default branch). " | |
| "The script fetches origin/<base-branch> and refuses to run if HEAD " | |
| "is behind it." | |
| ), | |
| ) | |
| parser.add_argument( | |
| "--skip-freshness-check", | |
| action="store_true", | |
| help=( | |
| "Bypass the 'branch is up to date' check. Only for intentional " | |
| "migrations against an older base. Pairs poorly with automation." | |
| ), | |
| ) | |
| args = parser.parse_args() | |
| create_migration( | |
| args.migration_name, | |
| allow_destructive=args.allow_destructive, | |
| base_branch=args.base_branch, | |
| skip_freshness_check=args.skip_freshness_check, | |
| ) | |
Xet Storage Details
- Size:
- 14.3 kB
- Xet hash:
- 2edc13266af74a537b8904c5a35239e9776424b2720eee28ce8a690c38497cff
·
Xet efficiently stores files, intelligently splitting them into unique chunks and accelerating uploads and downloads. More info.