Rename terminology to industry standard terms
- Grove → Project - Tree → Package - Fruit → Artifact - Graft → Tag - Cultivate → Upload - Harvest → Download Updated across: - Backend models, schemas, and routes - Frontend types, API client, and components - README documentation - API endpoints now use /project/:project/packages pattern
This commit is contained in:
Mondo Diaz
@@ -7,13 +7,13 @@ import re
|
||||
|
||||
from .database import get_db
|
||||
from .storage import get_storage, S3Storage
|
||||
from .models import Grove, Tree, Fruit, Graft, Harvest, Consumer
|
||||
from .models import Project, Package, Artifact, Tag, Upload, Consumer
|
||||
from .schemas import (
|
||||
GroveCreate, GroveResponse,
|
||||
TreeCreate, TreeResponse,
|
||||
FruitResponse,
|
||||
GraftCreate, GraftResponse,
|
||||
CultivateResponse,
|
||||
ProjectCreate, ProjectResponse,
|
||||
PackageCreate, PackageResponse,
|
||||
ArtifactResponse,
|
||||
TagCreate, TagResponse,
|
||||
UploadResponse,
|
||||
ConsumerResponse,
|
||||
HealthResponse,
|
||||
)
|
||||
@@ -38,81 +38,81 @@ def health_check():
|
||||
return HealthResponse(status="ok")
|
||||
|
||||
|
||||
# Grove routes
|
||||
@router.get("/api/v1/groves", response_model=List[GroveResponse])
|
||||
def list_groves(request: Request, db: Session = Depends(get_db)):
|
||||
# Project routes
|
||||
@router.get("/api/v1/projects", response_model=List[ProjectResponse])
|
||||
def list_projects(request: Request, db: Session = Depends(get_db)):
|
||||
user_id = get_user_id(request)
|
||||
groves = db.query(Grove).filter(
|
||||
or_(Grove.is_public == True, Grove.created_by == user_id)
|
||||
).order_by(Grove.name).all()
|
||||
return groves
|
||||
projects = db.query(Project).filter(
|
||||
or_(Project.is_public == True, Project.created_by == user_id)
|
||||
).order_by(Project.name).all()
|
||||
return projects
|
||||
|
||||
|
||||
@router.post("/api/v1/groves", response_model=GroveResponse)
|
||||
def create_grove(grove: GroveCreate, request: Request, db: Session = Depends(get_db)):
|
||||
@router.post("/api/v1/projects", response_model=ProjectResponse)
|
||||
def create_project(project: ProjectCreate, request: Request, db: Session = Depends(get_db)):
|
||||
user_id = get_user_id(request)
|
||||
|
||||
existing = db.query(Grove).filter(Grove.name == grove.name).first()
|
||||
existing = db.query(Project).filter(Project.name == project.name).first()
|
||||
if existing:
|
||||
raise HTTPException(status_code=400, detail="Grove already exists")
|
||||
raise HTTPException(status_code=400, detail="Project already exists")
|
||||
|
||||
db_grove = Grove(
|
||||
name=grove.name,
|
||||
description=grove.description,
|
||||
is_public=grove.is_public,
|
||||
db_project = Project(
|
||||
name=project.name,
|
||||
description=project.description,
|
||||
is_public=project.is_public,
|
||||
created_by=user_id,
|
||||
)
|
||||
db.add(db_grove)
|
||||
db.add(db_project)
|
||||
db.commit()
|
||||
db.refresh(db_grove)
|
||||
return db_grove
|
||||
db.refresh(db_project)
|
||||
return db_project
|
||||
|
||||
|
||||
@router.get("/api/v1/groves/{grove_name}", response_model=GroveResponse)
|
||||
def get_grove(grove_name: str, db: Session = Depends(get_db)):
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
return grove
|
||||
@router.get("/api/v1/projects/{project_name}", response_model=ProjectResponse)
|
||||
def get_project(project_name: str, db: Session = Depends(get_db)):
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
return project
|
||||
|
||||
|
||||
# Tree routes
|
||||
@router.get("/api/v1/grove/{grove_name}/trees", response_model=List[TreeResponse])
|
||||
def list_trees(grove_name: str, db: Session = Depends(get_db)):
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
# Package routes
|
||||
@router.get("/api/v1/project/{project_name}/packages", response_model=List[PackageResponse])
|
||||
def list_packages(project_name: str, db: Session = Depends(get_db)):
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
trees = db.query(Tree).filter(Tree.grove_id == grove.id).order_by(Tree.name).all()
|
||||
return trees
|
||||
packages = db.query(Package).filter(Package.project_id == project.id).order_by(Package.name).all()
|
||||
return packages
|
||||
|
||||
|
||||
@router.post("/api/v1/grove/{grove_name}/trees", response_model=TreeResponse)
|
||||
def create_tree(grove_name: str, tree: TreeCreate, db: Session = Depends(get_db)):
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
@router.post("/api/v1/project/{project_name}/packages", response_model=PackageResponse)
|
||||
def create_package(project_name: str, package: PackageCreate, db: Session = Depends(get_db)):
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
existing = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree.name).first()
|
||||
existing = db.query(Package).filter(Package.project_id == project.id, Package.name == package.name).first()
|
||||
if existing:
|
||||
raise HTTPException(status_code=400, detail="Tree already exists in this grove")
|
||||
raise HTTPException(status_code=400, detail="Package already exists in this project")
|
||||
|
||||
db_tree = Tree(
|
||||
grove_id=grove.id,
|
||||
name=tree.name,
|
||||
description=tree.description,
|
||||
db_package = Package(
|
||||
project_id=project.id,
|
||||
name=package.name,
|
||||
description=package.description,
|
||||
)
|
||||
db.add(db_tree)
|
||||
db.add(db_package)
|
||||
db.commit()
|
||||
db.refresh(db_tree)
|
||||
return db_tree
|
||||
db.refresh(db_package)
|
||||
return db_package
|
||||
|
||||
|
||||
# Cultivate (upload)
|
||||
@router.post("/api/v1/grove/{grove_name}/{tree_name}/cultivate", response_model=CultivateResponse)
|
||||
def cultivate(
|
||||
grove_name: str,
|
||||
tree_name: str,
|
||||
# Upload artifact
|
||||
@router.post("/api/v1/project/{project_name}/{package_name}/upload", response_model=UploadResponse)
|
||||
def upload_artifact(
|
||||
project_name: str,
|
||||
package_name: str,
|
||||
request: Request,
|
||||
file: UploadFile = File(...),
|
||||
tag: Optional[str] = Form(None),
|
||||
@@ -121,24 +121,24 @@ def cultivate(
|
||||
):
|
||||
user_id = get_user_id(request)
|
||||
|
||||
# Get grove and tree
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
# Get project and package
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
|
||||
if not tree:
|
||||
raise HTTPException(status_code=404, detail="Tree not found")
|
||||
package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
|
||||
if not package:
|
||||
raise HTTPException(status_code=404, detail="Package not found")
|
||||
|
||||
# Store file
|
||||
sha256_hash, size, s3_key = storage.store(file.file)
|
||||
|
||||
# Create or update fruit record
|
||||
fruit = db.query(Fruit).filter(Fruit.id == sha256_hash).first()
|
||||
if fruit:
|
||||
fruit.ref_count += 1
|
||||
# Create or update artifact record
|
||||
artifact = db.query(Artifact).filter(Artifact.id == sha256_hash).first()
|
||||
if artifact:
|
||||
artifact.ref_count += 1
|
||||
else:
|
||||
fruit = Fruit(
|
||||
artifact = Artifact(
|
||||
id=sha256_hash,
|
||||
size=size,
|
||||
content_type=file.content_type,
|
||||
@@ -146,188 +146,188 @@ def cultivate(
|
||||
created_by=user_id,
|
||||
s3_key=s3_key,
|
||||
)
|
||||
db.add(fruit)
|
||||
db.add(artifact)
|
||||
|
||||
# Record harvest
|
||||
harvest = Harvest(
|
||||
fruit_id=sha256_hash,
|
||||
tree_id=tree.id,
|
||||
# Record upload
|
||||
upload = Upload(
|
||||
artifact_id=sha256_hash,
|
||||
package_id=package.id,
|
||||
original_name=file.filename,
|
||||
harvested_by=user_id,
|
||||
uploaded_by=user_id,
|
||||
source_ip=request.client.host if request.client else None,
|
||||
)
|
||||
db.add(harvest)
|
||||
db.add(upload)
|
||||
|
||||
# Create tag if provided
|
||||
if tag:
|
||||
existing_graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == tag).first()
|
||||
if existing_graft:
|
||||
existing_graft.fruit_id = sha256_hash
|
||||
existing_graft.created_by = user_id
|
||||
existing_tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag).first()
|
||||
if existing_tag:
|
||||
existing_tag.artifact_id = sha256_hash
|
||||
existing_tag.created_by = user_id
|
||||
else:
|
||||
graft = Graft(
|
||||
tree_id=tree.id,
|
||||
new_tag = Tag(
|
||||
package_id=package.id,
|
||||
name=tag,
|
||||
fruit_id=sha256_hash,
|
||||
artifact_id=sha256_hash,
|
||||
created_by=user_id,
|
||||
)
|
||||
db.add(graft)
|
||||
db.add(new_tag)
|
||||
|
||||
db.commit()
|
||||
|
||||
return CultivateResponse(
|
||||
fruit_id=sha256_hash,
|
||||
return UploadResponse(
|
||||
artifact_id=sha256_hash,
|
||||
size=size,
|
||||
grove=grove_name,
|
||||
tree=tree_name,
|
||||
project=project_name,
|
||||
package=package_name,
|
||||
tag=tag,
|
||||
)
|
||||
|
||||
|
||||
# Harvest (download)
|
||||
@router.get("/api/v1/grove/{grove_name}/{tree_name}/+/{ref}")
|
||||
def harvest(
|
||||
grove_name: str,
|
||||
tree_name: str,
|
||||
# Download artifact
|
||||
@router.get("/api/v1/project/{project_name}/{package_name}/+/{ref}")
|
||||
def download_artifact(
|
||||
project_name: str,
|
||||
package_name: str,
|
||||
ref: str,
|
||||
db: Session = Depends(get_db),
|
||||
storage: S3Storage = Depends(get_storage),
|
||||
):
|
||||
# Get grove and tree
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
# Get project and package
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
|
||||
if not tree:
|
||||
raise HTTPException(status_code=404, detail="Tree not found")
|
||||
package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
|
||||
if not package:
|
||||
raise HTTPException(status_code=404, detail="Package not found")
|
||||
|
||||
# Resolve reference to fruit
|
||||
fruit = None
|
||||
# Resolve reference to artifact
|
||||
artifact = None
|
||||
|
||||
# Check for explicit prefixes
|
||||
if ref.startswith("fruit:"):
|
||||
fruit_id = ref[6:]
|
||||
fruit = db.query(Fruit).filter(Fruit.id == fruit_id).first()
|
||||
if ref.startswith("artifact:"):
|
||||
artifact_id = ref[9:]
|
||||
artifact = db.query(Artifact).filter(Artifact.id == artifact_id).first()
|
||||
elif ref.startswith("tag:") or ref.startswith("version:"):
|
||||
tag_name = ref.split(":", 1)[1]
|
||||
graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == tag_name).first()
|
||||
if graft:
|
||||
fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
|
||||
tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag_name).first()
|
||||
if tag:
|
||||
artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
|
||||
else:
|
||||
# Try as tag name first
|
||||
graft = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == ref).first()
|
||||
if graft:
|
||||
fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
|
||||
tag = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == ref).first()
|
||||
if tag:
|
||||
artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
|
||||
else:
|
||||
# Try as direct fruit ID
|
||||
fruit = db.query(Fruit).filter(Fruit.id == ref).first()
|
||||
# Try as direct artifact ID
|
||||
artifact = db.query(Artifact).filter(Artifact.id == ref).first()
|
||||
|
||||
if not fruit:
|
||||
if not artifact:
|
||||
raise HTTPException(status_code=404, detail="Artifact not found")
|
||||
|
||||
# Stream from S3
|
||||
stream = storage.get_stream(fruit.s3_key)
|
||||
stream = storage.get_stream(artifact.s3_key)
|
||||
|
||||
filename = fruit.original_name or f"{fruit.id}"
|
||||
filename = artifact.original_name or f"{artifact.id}"
|
||||
|
||||
return StreamingResponse(
|
||||
stream,
|
||||
media_type=fruit.content_type or "application/octet-stream",
|
||||
media_type=artifact.content_type or "application/octet-stream",
|
||||
headers={"Content-Disposition": f'attachment; filename="{filename}"'},
|
||||
)
|
||||
|
||||
|
||||
# Compatibility route
|
||||
@router.get("/grove/{grove_name}/{tree_name}/+/{ref}")
|
||||
def harvest_compat(
|
||||
grove_name: str,
|
||||
tree_name: str,
|
||||
@router.get("/project/{project_name}/{package_name}/+/{ref}")
|
||||
def download_artifact_compat(
|
||||
project_name: str,
|
||||
package_name: str,
|
||||
ref: str,
|
||||
db: Session = Depends(get_db),
|
||||
storage: S3Storage = Depends(get_storage),
|
||||
):
|
||||
return harvest(grove_name, tree_name, ref, db, storage)
|
||||
return download_artifact(project_name, package_name, ref, db, storage)
|
||||
|
||||
|
||||
# Graft routes
|
||||
@router.get("/api/v1/grove/{grove_name}/{tree_name}/grafts", response_model=List[GraftResponse])
|
||||
def list_grafts(grove_name: str, tree_name: str, db: Session = Depends(get_db)):
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
# Tag routes
|
||||
@router.get("/api/v1/project/{project_name}/{package_name}/tags", response_model=List[TagResponse])
|
||||
def list_tags(project_name: str, package_name: str, db: Session = Depends(get_db)):
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
|
||||
if not tree:
|
||||
raise HTTPException(status_code=404, detail="Tree not found")
|
||||
package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
|
||||
if not package:
|
||||
raise HTTPException(status_code=404, detail="Package not found")
|
||||
|
||||
grafts = db.query(Graft).filter(Graft.tree_id == tree.id).order_by(Graft.name).all()
|
||||
return grafts
|
||||
tags = db.query(Tag).filter(Tag.package_id == package.id).order_by(Tag.name).all()
|
||||
return tags
|
||||
|
||||
|
||||
@router.post("/api/v1/grove/{grove_name}/{tree_name}/graft", response_model=GraftResponse)
|
||||
def create_graft(
|
||||
grove_name: str,
|
||||
tree_name: str,
|
||||
graft: GraftCreate,
|
||||
@router.post("/api/v1/project/{project_name}/{package_name}/tags", response_model=TagResponse)
|
||||
def create_tag(
|
||||
project_name: str,
|
||||
package_name: str,
|
||||
tag: TagCreate,
|
||||
request: Request,
|
||||
db: Session = Depends(get_db),
|
||||
):
|
||||
user_id = get_user_id(request)
|
||||
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
|
||||
if not tree:
|
||||
raise HTTPException(status_code=404, detail="Tree not found")
|
||||
package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
|
||||
if not package:
|
||||
raise HTTPException(status_code=404, detail="Package not found")
|
||||
|
||||
# Verify fruit exists
|
||||
fruit = db.query(Fruit).filter(Fruit.id == graft.fruit_id).first()
|
||||
if not fruit:
|
||||
raise HTTPException(status_code=404, detail="Fruit not found")
|
||||
# Verify artifact exists
|
||||
artifact = db.query(Artifact).filter(Artifact.id == tag.artifact_id).first()
|
||||
if not artifact:
|
||||
raise HTTPException(status_code=404, detail="Artifact not found")
|
||||
|
||||
# Create or update graft
|
||||
existing = db.query(Graft).filter(Graft.tree_id == tree.id, Graft.name == graft.name).first()
|
||||
# Create or update tag
|
||||
existing = db.query(Tag).filter(Tag.package_id == package.id, Tag.name == tag.name).first()
|
||||
if existing:
|
||||
existing.fruit_id = graft.fruit_id
|
||||
existing.artifact_id = tag.artifact_id
|
||||
existing.created_by = user_id
|
||||
db.commit()
|
||||
db.refresh(existing)
|
||||
return existing
|
||||
|
||||
db_graft = Graft(
|
||||
tree_id=tree.id,
|
||||
name=graft.name,
|
||||
fruit_id=graft.fruit_id,
|
||||
db_tag = Tag(
|
||||
package_id=package.id,
|
||||
name=tag.name,
|
||||
artifact_id=tag.artifact_id,
|
||||
created_by=user_id,
|
||||
)
|
||||
db.add(db_graft)
|
||||
db.add(db_tag)
|
||||
db.commit()
|
||||
db.refresh(db_graft)
|
||||
return db_graft
|
||||
db.refresh(db_tag)
|
||||
return db_tag
|
||||
|
||||
|
||||
# Consumer routes
|
||||
@router.get("/api/v1/grove/{grove_name}/{tree_name}/consumers", response_model=List[ConsumerResponse])
|
||||
def get_consumers(grove_name: str, tree_name: str, db: Session = Depends(get_db)):
|
||||
grove = db.query(Grove).filter(Grove.name == grove_name).first()
|
||||
if not grove:
|
||||
raise HTTPException(status_code=404, detail="Grove not found")
|
||||
@router.get("/api/v1/project/{project_name}/{package_name}/consumers", response_model=List[ConsumerResponse])
|
||||
def get_consumers(project_name: str, package_name: str, db: Session = Depends(get_db)):
|
||||
project = db.query(Project).filter(Project.name == project_name).first()
|
||||
if not project:
|
||||
raise HTTPException(status_code=404, detail="Project not found")
|
||||
|
||||
tree = db.query(Tree).filter(Tree.grove_id == grove.id, Tree.name == tree_name).first()
|
||||
if not tree:
|
||||
raise HTTPException(status_code=404, detail="Tree not found")
|
||||
package = db.query(Package).filter(Package.project_id == project.id, Package.name == package_name).first()
|
||||
if not package:
|
||||
raise HTTPException(status_code=404, detail="Package not found")
|
||||
|
||||
consumers = db.query(Consumer).filter(Consumer.tree_id == tree.id).order_by(Consumer.last_access.desc()).all()
|
||||
consumers = db.query(Consumer).filter(Consumer.package_id == package.id).order_by(Consumer.last_access.desc()).all()
|
||||
return consumers
|
||||
|
||||
|
||||
# Fruit by ID
|
||||
@router.get("/api/v1/fruit/{fruit_id}", response_model=FruitResponse)
|
||||
def get_fruit(fruit_id: str, db: Session = Depends(get_db)):
|
||||
fruit = db.query(Fruit).filter(Fruit.id == fruit_id).first()
|
||||
if not fruit:
|
||||
raise HTTPException(status_code=404, detail="Fruit not found")
|
||||
return fruit
|
||||
# Artifact by ID
|
||||
@router.get("/api/v1/artifact/{artifact_id}", response_model=ArtifactResponse)
|
||||
def get_artifact(artifact_id: str, db: Session = Depends(get_db)):
|
||||
artifact = db.query(Artifact).filter(Artifact.id == artifact_id).first()
|
||||
if not artifact:
|
||||
raise HTTPException(status_code=404, detail="Artifact not found")
|
||||
return artifact
|
||||
|
||||
Reference in New Issue
Block a user