refactor: node deletion

apps/backend/internal/virtualfs/err.go

@@ -3,6 +3,7 @@ package virtualfs
 import "errors"
 
 var (
-	ErrNodeNotFound = errors.New("node not found")
-	ErrNodeConflict = errors.New("node conflict")
+	ErrNodeNotFound         = errors.New("node not found")
+	ErrNodeConflict         = errors.New("node conflict")
+	ErrUnsupportedOperation = errors.New("unsupported operation")
 )

apps/backend/internal/virtualfs/flat_key_resolver.go

@@ -0,0 +1,35 @@
+package virtualfs
+
+import (
+	"context"
+
+	"github.com/get-drexa/drexa/internal/blob"
+	"github.com/google/uuid"
+)
+
+type FlatKeyResolver struct{}
+
+var _ BlobKeyResolver = &FlatKeyResolver{}
+
+func NewFlatKeyResolver() *FlatKeyResolver {
+	return &FlatKeyResolver{}
+}
+
+func (r *FlatKeyResolver) KeyMode() blob.KeyMode {
+	return blob.KeyModeStable
+}
+
+func (r *FlatKeyResolver) Resolve(ctx context.Context, node *Node) (blob.Key, error) {
+	if node.BlobKey == "" {
+		id, err := uuid.NewV7()
+		if err != nil {
+			return "", err
+		}
+		return blob.Key(id.String()), nil
+	}
+	return node.BlobKey, nil
+}
+
+func (r *FlatKeyResolver) ResolveDeletionKeys(ctx context.Context, node *Node, allKeys []blob.Key) (*DeletionPlan, error) {
+	return &DeletionPlan{Keys: allKeys}, nil
+}

apps/backend/internal/virtualfs/hierarchical_key_resolver.go

@@ -0,0 +1,39 @@
+package virtualfs
+
+import (
+	"context"
+
+	"github.com/get-drexa/drexa/internal/blob"
+	"github.com/uptrace/bun"
+)
+
+type HierarchicalKeyResolver struct {
+	db *bun.DB
+}
+
+var _ BlobKeyResolver = &HierarchicalKeyResolver{}
+
+func NewHierarchicalKeyResolver(db *bun.DB) *HierarchicalKeyResolver {
+	return &HierarchicalKeyResolver{db: db}
+}
+
+func (r *HierarchicalKeyResolver) KeyMode() blob.KeyMode {
+	return blob.KeyModeDerived
+}
+
+func (r *HierarchicalKeyResolver) Resolve(ctx context.Context, node *Node) (blob.Key, error) {
+	path, err := buildNodeAbsolutePath(ctx, r.db, node.ID)
+	if err != nil {
+		return "", err
+	}
+
+	return blob.Key(path), nil
+}
+
+func (r *HierarchicalKeyResolver) ResolveDeletionKeys(ctx context.Context, node *Node, allKeys []blob.Key) (*DeletionPlan, error) {
+	path, err := buildNodeAbsolutePath(ctx, r.db, node.ID)
+	if err != nil {
+		return nil, err
+	}
+	return &DeletionPlan{Prefix: blob.Key(path)}, nil
+}

apps/backend/internal/virtualfs/key_resolver.go

@@ -4,53 +4,15 @@ import (
 	"context"
 
 	"github.com/get-drexa/drexa/internal/blob"
-	"github.com/google/uuid"
-	"github.com/uptrace/bun"
 )
 
 type BlobKeyResolver interface {
 	KeyMode() blob.KeyMode
 	Resolve(ctx context.Context, node *Node) (blob.Key, error)
+	ResolveDeletionKeys(ctx context.Context, node *Node, allKeys []blob.Key) (*DeletionPlan, error)
 }
 
-type FlatKeyResolver struct{}
-
-func NewFlatKeyResolver() *FlatKeyResolver {
-	return &FlatKeyResolver{}
-}
-
-func (r *FlatKeyResolver) KeyMode() blob.KeyMode {
-	return blob.KeyModeStable
-}
-
-func (r *FlatKeyResolver) Resolve(ctx context.Context, node *Node) (blob.Key, error) {
-	if node.BlobKey == "" {
-		id, err := uuid.NewV7()
-		if err != nil {
-			return "", err
-		}
-		return blob.Key(id.String()), nil
-	}
-	return node.BlobKey, nil
-}
-
-type HierarchicalKeyResolver struct {
-	db *bun.DB
-}
-
-func NewHierarchicalKeyResolver(db *bun.DB) *HierarchicalKeyResolver {
-	return &HierarchicalKeyResolver{db: db}
-}
-
-func (r *HierarchicalKeyResolver) KeyMode() blob.KeyMode {
-	return blob.KeyModeDerived
-}
-
-func (r *HierarchicalKeyResolver) Resolve(ctx context.Context, node *Node) (blob.Key, error) {
-	path, err := buildNodeAbsolutePath(ctx, r.db, node.ID)
-	if err != nil {
-		return "", err
-	}
-
-	return blob.Key(path), nil
+type DeletionPlan struct {
+	Prefix blob.Key
+	Keys   []blob.Key
 }

apps/backend/internal/virtualfs/vfs.go

@@ -385,7 +385,31 @@ func (vfs *VirtualFS) PermanentlyDeleteNode(ctx context.Context, node *Node) err
 	if !node.IsAccessible() {
 		return ErrNodeNotFound
 	}
+	switch node.Kind {
+	case NodeKindFile:
+		return vfs.permanentlyDeleteFileNode(ctx, node)
+	case NodeKindDirectory:
+		return vfs.permanentlyDeleteDirectoryNode(ctx, node)
+	default:
+		return ErrUnsupportedOperation
+	}
+}
 
+func (vfs *VirtualFS) permanentlyDeleteFileNode(ctx context.Context, node *Node) error {
+	err := vfs.blobStore.Delete(ctx, node.BlobKey)
+	if err != nil {
+		return err
+	}
+
+	_, err = vfs.db.NewDelete().Model(node).WherePK().Exec(ctx)
+	if err != nil {
+		return err
+	}
+
+	return nil
+}
+
+func (vfs *VirtualFS) permanentlyDeleteDirectoryNode(ctx context.Context, node *Node) error {
 	const descendantsQuery = `WITH RECURSIVE descendants AS (
 		SELECT id, blob_key FROM vfs_nodes WHERE id = ?
 		UNION ALL
@@ -399,46 +423,56 @@ func (vfs *VirtualFS) PermanentlyDeleteNode(ctx context.Context, node *Node) err
 		BlobKey blob.Key  `bun:"blob_key"`
 	}
 
-	var blobKeys []blob.Key
+	tx, err := vfs.db.BeginTx(ctx, nil)
+	if err != nil {
+		return err
+	}
+	defer tx.Rollback()
 
-	err := vfs.db.RunInTx(ctx, nil, func(ctx context.Context, tx bun.Tx) error {
-		var records []nodeRecord
-		err := tx.NewRaw(descendantsQuery, node.ID).Scan(ctx, &records)
-		if err != nil {
-			if errors.Is(err, sql.ErrNoRows) {
-				return ErrNodeNotFound
-			}
-			return err
-		}
-
-		if len(records) == 0 {
+	var records []nodeRecord
+	err = tx.NewRaw(descendantsQuery, node.ID).Scan(ctx, &records)
+	if err != nil {
+		if errors.Is(err, sql.ErrNoRows) {
 			return ErrNodeNotFound
 		}
-
-		nodeIDs := make([]uuid.UUID, 0, len(records))
-		for _, r := range records {
-			nodeIDs = append(nodeIDs, r.ID)
-			if !r.BlobKey.IsNil() {
-				blobKeys = append(blobKeys, r.BlobKey)
-			}
-		}
-
-		_, err = tx.NewDelete().
-			Model((*Node)(nil)).
-			Where("id IN (?)", bun.In(nodeIDs)).
-			Exec(ctx)
 		return err
-	})
+	}
+
+	if len(records) == 0 {
+		return ErrNodeNotFound
+	}
+
+	nodeIDs := make([]uuid.UUID, 0, len(records))
+	blobKeys := make([]blob.Key, 0, len(records))
+	for _, r := range records {
+		nodeIDs = append(nodeIDs, r.ID)
+		if !r.BlobKey.IsNil() {
+			blobKeys = append(blobKeys, r.BlobKey)
+		}
+	}
+
+	plan, err := vfs.keyResolver.ResolveDeletionKeys(ctx, node, blobKeys)
 	if err != nil {
 		return err
 	}
 
-	// Delete blobs outside transaction (best effort)
-	for _, key := range blobKeys {
-		_ = vfs.blobStore.Delete(ctx, key)
+	_, err = tx.NewDelete().
+		Model((*Node)(nil)).
+		Where("id IN (?)", bun.In(nodeIDs)).
+		Exec(ctx)
+	if err != nil {
+		return err
 	}
 
-	return nil
+	if !plan.Prefix.IsNil() {
+		_ = vfs.blobStore.DeletePrefix(ctx, plan.Prefix)
+	} else {
+		for _, key := range plan.Keys {
+			_ = vfs.blobStore.Delete(ctx, key)
+		}
+	}
+
+	return tx.Commit()
 }
 
 func (vfs *VirtualFS) generatePublicID() (string, error) {