feat: allowing users to delete images from lists

backend/models/lists.go

@@ -195,7 +195,23 @@ func (m ListModel) Save(ctx context.Context, userId uuid.UUID, name string, desc
 	return listWithItems, err
 }
 
-func (m ListModel) SaveInto(ctx context.Context, listId uuid.UUID, imageId uuid.UUID, schemaValues []IDValue) error {
+func (m ListModel) SaveInto(ctx context.Context, listID uuid.UUID, imageID uuid.UUID, schemaValues []IDValue) error {
+	tx, err := m.dbPool.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+
+	var imageList model.ImageLists
+	stmt := ImageLists.INSERT(ImageLists.ListID, ImageLists.ImageID).
+		VALUES(listID, imageID).
+		RETURNING(ImageLists.ID)
+
+	err = stmt.QueryContext(ctx, m.dbPool, &imageList)
+	if err != nil {
+		tx.Rollback()
+		return fmt.Errorf("Could not insert new list. %s", err)
+	}
+
 	imageSchemaItems := make([]model.ImageSchemaItems, len(schemaValues))
 
 	for i, v := range schemaValues {
@@ -205,24 +221,10 @@ func (m ListModel) SaveInto(ctx context.Context, listId uuid.UUID, imageId uuid.
 		}
 
 		imageSchemaItems[i].SchemaItemID = parsedId
-		imageSchemaItems[i].ImageID = imageId
+		imageSchemaItems[i].ImageID = imageList.ID
 		imageSchemaItems[i].Value = &v.Value
 	}
 
-	tx, err := m.dbPool.BeginTx(ctx, nil)
-	if err != nil {
-		return err
-	}
-
-	stmt := ImageLists.INSERT(ImageLists.ListID, ImageLists.ImageID).
-		VALUES(listId, imageId)
-
-	_, err = stmt.ExecContext(ctx, tx)
-	if err != nil {
-		tx.Rollback()
-		return fmt.Errorf("Could not insert new list. %s", err)
-	}
-
 	insertSchemaItemsStmt := ImageSchemaItems.
 		INSERT(ImageSchemaItems.Value, ImageSchemaItems.SchemaItemID, ImageSchemaItems.ImageID).
 		MODELS(imageSchemaItems)
@@ -251,6 +253,18 @@ func (m ListModel) SaveProcessing(ctx context.Context, userID uuid.UUID, title s
 // DELETE methods
 // ========================================
 
+func (m ListModel) DeleteImage(ctx context.Context, listID uuid.UUID, imageID uuid.UUID) error {
+	deleteImageListStmt := ImageLists.DELETE().
+		WHERE(
+			ImageLists.ListID.EQ(UUID(listID)).
+				AND(ImageLists.ImageID.EQ(UUID(imageID))),
+		)
+
+	_, err := deleteImageListStmt.ExecContext(ctx, m.dbPool)
+
+	return err
+}
+
 func (m ListModel) Delete(ctx context.Context, listID uuid.UUID, userID uuid.UUID) error {
 	// First verify the list belongs to the user
 	checkOwnershipStmt := Lists.

backend/models/user.go

@@ -107,7 +107,7 @@ func (m UserModel) ListWithImages(ctx context.Context, userId uuid.UUID) ([]List
 				INNER_JOIN(Schemas, Schemas.ListID.EQ(Lists.ID)).
 				INNER_JOIN(SchemaItems, SchemaItems.SchemaID.EQ(Schemas.ID)).
 				LEFT_JOIN(ImageLists, ImageLists.ListID.EQ(Lists.ID)).
-				LEFT_JOIN(ImageSchemaItems, ImageSchemaItems.ImageID.EQ(ImageLists.ImageID)),
+				LEFT_JOIN(ImageSchemaItems, ImageSchemaItems.ImageID.EQ(ImageLists.ID)),
 		).
 		WHERE(Lists.UserID.EQ(UUID(userId)))
 

backend/schema.sql

@@ -93,7 +93,7 @@ CREATE TABLE haystack.image_schema_items (
     value TEXT,
 
     schema_item_id UUID NOT NULL REFERENCES haystack.schema_items (id),
-    image_id UUID NOT NULL REFERENCES haystack.image (id) ON DELETE CASCADE
+    image_id UUID NOT NULL REFERENCES haystack.image_lists (id) ON DELETE CASCADE
 );
 
 /* -----| Indexes |----- */

backend/stacks/handler.go

@@ -13,11 +13,15 @@ import (
 
 	"github.com/charmbracelet/log"
 	"github.com/go-chi/chi/v5"
+	"github.com/google/uuid"
 )
 
 type StackHandler struct {
-	logger        *log.Logger
-	stackModel    models.ListModel
+	logger *log.Logger
+
+	imageModel models.ImageModel
+	stackModel models.ListModel
+
 	limitsManager limits.LimitsManagerMethods
 }
 
@@ -94,6 +98,47 @@ func (h *StackHandler) deleteStack(w http.ResponseWriter, r *http.Request) {
 	w.WriteHeader(http.StatusOK)
 }
 
+func (h *StackHandler) deleteImageFromStack(w http.ResponseWriter, r *http.Request) {
+	ctx := r.Context()
+
+	stringImageID := chi.URLParam(r, "imageID")
+	stringListID := chi.URLParam(r, "listID")
+
+	imageID, err := uuid.Parse(stringImageID)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	listID, err := uuid.Parse(stringListID)
+	if err != nil {
+		w.WriteHeader(http.StatusBadRequest)
+		return
+	}
+
+	// TODO: this should be extracted into a middleware of sorts
+	userID, err := middleware.GetUserID(ctx, h.logger, w)
+	if err != nil {
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
+	isAuthorized := h.imageModel.IsUserAuthorized(ctx, imageID, userID)
+	if !isAuthorized {
+		w.WriteHeader(http.StatusUnauthorized)
+		return
+	}
+
+	err = h.stackModel.DeleteImage(ctx, listID, imageID)
+	if err != nil {
+		h.logger.Warn("failed to delete image from list", "error", err)
+		w.WriteHeader(http.StatusInternalServerError)
+		return
+	}
+
+	w.WriteHeader(http.StatusOK)
+}
+
 type CreateStackBody struct {
 	Title string `json:"title"`
 
@@ -149,15 +194,18 @@ func (h *StackHandler) CreateRoutes(r chi.Router) {
 		r.Post("/", middleware.WithLimit(h.logger, h.limitsManager.HasReachedStackLimit, middleware.WithValidatedPost(h.createStack)))
 		r.Patch("/{listID}", middleware.WithValidatedPost(h.editStack))
 		r.Delete("/{listID}", h.deleteStack)
+		r.Delete("/{listID}/{imageID}", h.deleteImageFromStack)
 	})
 }
 
 func CreateStackHandler(db *sql.DB, limitsManager limits.LimitsManagerMethods) StackHandler {
 	stackModel := models.NewListModel(db)
+	imageModel := models.NewImageModel(db)
 	logger := log.New(os.Stdout).WithPrefix("Stacks")
 
 	return StackHandler{
 		logger,
+		imageModel,
 		stackModel,
 		limitsManager,
 	}