-
- hello world
", 100, "hello world"}, + {"collapses whitespace", "hello\n\n world\t!
", 100, "hello world !"}, + {"truncates with ellipsis", "abcdefghij", 5, "abcde…"}, + {"strips mention markup", `hi @bob ok
`, 100, "hi @bob ok"}, + } + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got := stripPreview(tc.in, tc.max) + if got != tc.want { + t.Errorf("stripPreview(%q, %d) = %q; want %q", tc.in, tc.max, got, tc.want) + } + }) + } +} + +func TestHumanFieldName(t *testing.T) { + tests := map[string]string{ + "start_date": "start date", + "target_date": "due date", + "parent": "parent", + "priority": "priority", + "name": "title", + "unknown": "unknown", + } + for in, want := range tests { + if got := humanFieldName(in); got != want { + t.Errorf("humanFieldName(%q) = %q; want %q", in, got, want) + } + } +} diff --git a/api/internal/service/page.go b/api/internal/service/page.go index 40ceb398..f157a2f7 100644 --- a/api/internal/service/page.go +++ b/api/internal/service/page.go @@ -3,25 +3,99 @@ package service import ( "context" "errors" + "strings" "github.com/Devlaner/devlane/api/internal/model" "github.com/Devlaner/devlane/api/internal/store" "github.com/google/uuid" ) -var ErrPageNotFound = errors.New("page not found") +var ( + ErrPageNotFound = errors.New("page not found") + ErrPageLocked = errors.New("page is locked") + ErrPageArchived = errors.New("page is archived") + ErrPageReadOnly = errors.New("no permission to edit this page") + ErrPageNotArchived = errors.New("page must be archived before deletion") + ErrPageBadParent = errors.New("invalid parent page") + ErrPageBadRequest = errors.New("invalid page request") +) -// PageService handles page business logic. +// PageService handles page business logic and permission gating. +// +// Permission model: +// - Public page (access=0): any workspace member can view; any workspace member +// can edit content unless is_locked is true (then only owner). Owner-only meta. +// - Private page (access=1): owner-only view + edit. +// - Archived page: read-only for everyone; owner can unarchive or delete. +// +// Workspace membership is the auth boundary. Project membership is not strictly +// required to view a public page in the workspace, since pages can be linked to +// multiple projects via project_pages. type PageService struct { pageStore *store.PageStore projectStore *store.ProjectStore ws *store.WorkspaceStore + favorites *store.UserFavoriteStore // optional — when nil, favorite endpoints return errors } func NewPageService(pageStore *store.PageStore, projectStore *store.ProjectStore, ws *store.WorkspaceStore) *PageService { return &PageService{pageStore: pageStore, projectStore: projectStore, ws: ws} } +// SetFavoriteStore wires the user_favorites store. Optional — without it, +// favorite endpoints return ErrPageNotFound (treated as 404). +func (s *PageService) SetFavoriteStore(f *store.UserFavoriteStore) { s.favorites = f } + +// ----- Permission helpers -------------------------------------------------- + +// canView returns true if userID may read the page. +// +// isMember must be true if userID is a member of page.WorkspaceID. The caller +// is responsible for that check; canView avoids re-querying it. +// +// Workspace membership is the auth boundary — even page owners lose access +// when they are removed from the workspace. +func canView(page *model.Page, userID uuid.UUID, isMember bool) bool { + if page == nil || !isMember { + return false + } + if page.OwnedByID == userID { + return true + } + return page.Access == model.PageAccessPublic +} + +// canEditContent returns true if userID may edit page body content right now. +// +// The lock blocks everyone except the owner. Archived pages are read-only. +// Private pages are owner-only. +func canEditContent(page *model.Page, userID uuid.UUID, isMember bool) bool { + if page == nil || !isMember { + return false + } + if page.ArchivedAt != nil { + return false + } + if page.OwnedByID == userID { + return true + } + if page.IsLocked { + return false + } + return page.Access == model.PageAccessPublic +} + +// canEditMeta returns true if userID may change name/access/parent. Owner-only, +// but the owner must still be a workspace member (auth boundary). +func canEditMeta(page *model.Page, userID uuid.UUID, isMember bool) bool { + if page == nil || !isMember { + return false + } + return page.OwnedByID == userID +} + +// ----- Common access guards ----------------------------------------------- + func (s *PageService) ensureWorkspaceAccess(ctx context.Context, workspaceSlug string, userID uuid.UUID) (uuid.UUID, error) { wrk, err := s.ws.GetBySlug(ctx, workspaceSlug) if err != nil { @@ -50,22 +124,90 @@ func (s *PageService) ensureProjectAccess(ctx context.Context, workspaceSlug str return nil } +// loadAndCheckView fetches a page and 404s if userID can't view it. Returns +// the page plus the workspace-membership flag so subsequent permission checks +// don't re-query. +func (s *PageService) loadAndCheckView(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) (*model.Page, bool, error) { + wrk, err := s.ws.GetBySlug(ctx, workspaceSlug) + if err != nil { + return nil, false, ErrProjectForbidden + } + isMember, _ := s.ws.IsMember(ctx, wrk.ID, userID) + page, err := s.pageStore.GetByID(ctx, pageID) + if err != nil { + return nil, false, ErrPageNotFound + } + if page.WorkspaceID != wrk.ID { + return nil, false, ErrPageNotFound + } + if !canView(page, userID, isMember) { + return nil, false, ErrPageNotFound + } + return page, isMember, nil +} + +// ----- Reads -------------------------------------------------------------- + // List lists pages for workspace or for a project (projectID optional). -func (s *PageService) List(ctx context.Context, workspaceSlug string, projectID *uuid.UUID, userID uuid.UUID) ([]model.Page, error) { +// Filters are honoured on the server (owner, archived, search, parent). +// +// Private pages owned by other users are filtered out post-query. The list +// page is small enough that this is fine; for very large workspaces we'd push +// the predicate into SQL. +func (s *PageService) List(ctx context.Context, workspaceSlug string, projectID *uuid.UUID, userID uuid.UUID, opts store.ListPagesOpts) ([]model.Page, error) { workspaceID, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) if err != nil { return nil, err } + var pages []model.Page if projectID != nil { if err := s.ensureProjectAccess(ctx, workspaceSlug, *projectID, userID); err != nil { return nil, err } - return s.pageStore.ListByProjectID(ctx, *projectID) + pages, err = s.pageStore.ListByProjectID(ctx, *projectID, opts) + } else { + pages, err = s.pageStore.ListByWorkspaceID(ctx, workspaceID, opts) + } + if err != nil { + return nil, err + } + out := pages[:0] + for _, p := range pages { + if p.Access == model.PageAccessPrivate && p.OwnedByID != userID { + continue + } + out = append(out, p) + } + return out, nil +} + +func (s *PageService) ListChildren(ctx context.Context, workspaceSlug string, parentID, userID uuid.UUID) ([]model.Page, error) { + parent, _, err := s.loadAndCheckView(ctx, workspaceSlug, parentID, userID) + if err != nil { + return nil, err + } + children, err := s.pageStore.ListChildrenByParentID(ctx, parent.ID) + if err != nil { + return nil, err + } + out := children[:0] + for _, p := range children { + if p.Access == model.PageAccessPrivate && p.OwnedByID != userID { + continue + } + out = append(out, p) } - return s.pageStore.ListByWorkspaceID(ctx, workspaceID) + return out, nil +} + +func (s *PageService) Get(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) (*model.Page, error) { + page, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + return page, err } -func (s *PageService) Create(ctx context.Context, workspaceSlug string, projectID *uuid.UUID, userID uuid.UUID, name, descriptionHTML string, access int16) (*model.Page, error) { +// ----- Writes ------------------------------------------------------------- + +func (s *PageService) Create(ctx context.Context, workspaceSlug string, projectID *uuid.UUID, userID uuid.UUID, name, html string, access int16, parentID *uuid.UUID) (*model.Page, error) { workspaceID, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) if err != nil { return nil, err @@ -75,76 +217,368 @@ func (s *PageService) Create(ctx context.Context, workspaceSlug string, projectI return nil, err } } + if access != model.PageAccessPublic && access != model.PageAccessPrivate { + access = model.PageAccessPublic + } + if html == "" { + html = "" + } + if name == "" { + name = "Untitled page" + } + // Validate parent (if any) before insert. We re-use loadAndCheckView so the + // caller must be able to *view* the proposed parent — not just be in the + // same workspace. This prevents creating a child under another user's + // private page where the parent would be inaccessible to the creator. + if parentID != nil { + if _, _, err := s.loadAndCheckView(ctx, workspaceSlug, *parentID, userID); err != nil { + return nil, ErrPageBadParent + } + } page := &model.Page{ Name: name, - DescriptionHTML: descriptionHTML, + DescriptionHTML: html, OwnedByID: userID, WorkspaceID: workspaceID, Access: access, + ParentID: parentID, + CreatedByID: &userID, + UpdatedByID: &userID, } - if err := s.pageStore.Create(ctx, page); err != nil { + // Insert the page and its project_pages link in a single transaction so a + // failed link doesn't leave behind an orphan page that's invisible to the + // project's pages list. + if err := s.pageStore.CreateWithProjectLink(ctx, page, projectID, &userID); err != nil { return nil, err } - if projectID != nil { - _ = s.pageStore.AddProjectPage(ctx, &model.ProjectPage{ - ProjectID: *projectID, - PageID: page.ID, - WorkspaceID: workspaceID, - }) - } + // Initial version row so history is anchored from page-creation onward. + _ = s.pageStore.CreateVersion(ctx, &model.PageVersion{ + PageID: page.ID, + WorkspaceID: workspaceID, + OwnedByID: userID, + DescriptionHTML: html, + DescriptionStripped: stripHTML(html), + }) return page, nil } -func (s *PageService) Get(ctx context.Context, workspaceSlug string, pageID uuid.UUID, userID uuid.UUID) (*model.Page, error) { - _, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) +// PageMetaUpdate carries the optional fields UpdateMeta accepts. nil values +// are left untouched; zero values for required fields are validated. +// +// LogoProps is owner-editable like name/access/parent: passing a non-nil value +// replaces the stored JSON, and SetLogoProps with a nil LogoProps clears it. +type PageMetaUpdate struct { + Name *string + Access *int16 + ParentID *uuid.UUID + ClearParent bool + LogoProps model.JSONMap + SetLogoProps bool +} + +// UpdateMeta changes name / access / parent / logo. Owner-only. +func (s *PageService) UpdateMeta(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID, in PageMetaUpdate) (*model.Page, error) { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) if err != nil { return nil, err } - page, err := s.pageStore.GetByID(ctx, pageID) + if !canEditMeta(page, userID, isMember) { + return nil, ErrPageReadOnly + } + if page.ArchivedAt != nil { + return nil, ErrPageArchived + } + if in.Name != nil { + page.Name = strings.TrimSpace(*in.Name) + } + if in.Access != nil { + if *in.Access != model.PageAccessPublic && *in.Access != model.PageAccessPrivate { + return nil, ErrPageBadRequest + } + page.Access = *in.Access + } + if in.ClearParent { + page.ParentID = nil + } else if in.ParentID != nil { + if err := s.validateParent(ctx, workspaceSlug, page, *in.ParentID, userID); err != nil { + return nil, err + } + page.ParentID = in.ParentID + } + if in.SetLogoProps { + page.LogoProps = in.LogoProps + } + page.UpdatedByID = &userID + if err := s.pageStore.Update(ctx, page); err != nil { + return nil, err + } + return page, nil +} + +// validateParent rejects parents that would corrupt the tree: +// - same page as itself, +// - caller cannot view the proposed parent, +// - parent is a descendant of the page being updated (cycle). +// +// Walks up the proposed parent's ancestor chain. Bounded by a max depth so a +// pre-existing cycle in the data can't loop us forever. +func (s *PageService) validateParent(ctx context.Context, workspaceSlug string, page *model.Page, parentID, userID uuid.UUID) error { + if parentID == page.ID { + return ErrPageBadParent + } + parent, _, err := s.loadAndCheckView(ctx, workspaceSlug, parentID, userID) if err != nil { - return nil, ErrPageNotFound + return ErrPageBadParent + } + const maxDepth = 64 + cursor := parent + for i := 0; i < maxDepth && cursor.ParentID != nil; i++ { + if *cursor.ParentID == page.ID { + return ErrPageBadParent + } + next, err := s.pageStore.GetByID(ctx, *cursor.ParentID) + if err != nil { + break + } + cursor = next + } + return nil +} + +// UpdateContent autosaves the body HTML. Records a version row on every save. +func (s *PageService) UpdateContent(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID, html string) (*model.Page, error) { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return nil, err } + if !canEditContent(page, userID, isMember) { + switch { + case page.ArchivedAt != nil: + return nil, ErrPageArchived + case page.IsLocked: + return nil, ErrPageLocked + default: + return nil, ErrPageReadOnly + } + } + if err := s.pageStore.UpdateContent(ctx, page.ID, html, userID); err != nil { + return nil, err + } + page.DescriptionHTML = html + page.UpdatedByID = &userID + _ = s.pageStore.CreateVersion(ctx, &model.PageVersion{ + PageID: page.ID, + WorkspaceID: page.WorkspaceID, + OwnedByID: userID, + DescriptionHTML: html, + DescriptionStripped: stripHTML(html), + }) return page, nil } -func (s *PageService) Update(ctx context.Context, workspaceSlug string, pageID uuid.UUID, userID uuid.UUID, name, descriptionHTML string, access *int16) (*model.Page, error) { - _, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) +func (s *PageService) Lock(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return err + } + if !canEditMeta(page, userID, isMember) { + return ErrPageReadOnly + } + return s.pageStore.Lock(ctx, page.ID) +} + +func (s *PageService) Unlock(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return err + } + if !canEditMeta(page, userID, isMember) { + return ErrPageReadOnly + } + return s.pageStore.Unlock(ctx, page.ID) +} + +func (s *PageService) Archive(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return err + } + if !canEditMeta(page, userID, isMember) { + return ErrPageReadOnly + } + // Archive the root and its descendants atomically so a failure doesn't + // leave a partially-archived subtree behind. + if err := s.pageStore.ArchiveTree(ctx, page.ID); err != nil { + return err + } + return nil +} + +func (s *PageService) Unarchive(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return err + } + if !canEditMeta(page, userID, isMember) { + return ErrPageReadOnly + } + return s.pageStore.Unarchive(ctx, page.ID) +} + +func (s *PageService) Delete(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return err + } + if !canEditMeta(page, userID, isMember) { + return ErrPageReadOnly + } + if page.ArchivedAt == nil { + return ErrPageNotArchived + } + return s.pageStore.Delete(ctx, page.ID) +} + +// Duplicate copies a page (and its project_pages links) into a new page owned +// by the caller. Any workspace member who can view the source may duplicate it. +func (s *PageService) Duplicate(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) (*model.Page, error) { + src, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) if err != nil { return nil, err } - page, err := s.pageStore.GetByID(ctx, pageID) + dup := &model.Page{ + Name: strings.TrimSpace(src.Name) + " (Copy)", + DescriptionHTML: src.DescriptionHTML, + OwnedByID: userID, + WorkspaceID: src.WorkspaceID, + Access: src.Access, + Color: src.Color, + ParentID: src.ParentID, + CreatedByID: &userID, + UpdatedByID: &userID, + } + projectIDs, err := s.pageStore.ListProjectIDsForPage(ctx, src.ID) if err != nil { - return nil, ErrPageNotFound + return nil, err + } + // Create the duplicate page + every project_pages link atomically. + if err := s.pageStore.DuplicateInTransaction(ctx, dup, projectIDs, &userID); err != nil { + return nil, err } - if page.OwnedByID != userID { + _ = s.pageStore.CreateVersion(ctx, &model.PageVersion{ + PageID: dup.ID, + WorkspaceID: dup.WorkspaceID, + OwnedByID: userID, + DescriptionHTML: dup.DescriptionHTML, + DescriptionStripped: stripHTML(dup.DescriptionHTML), + }) + return dup, nil +} + +// ----- Versions ----------------------------------------------------------- + +func (s *PageService) ListVersions(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) ([]model.PageVersion, error) { + page, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return nil, err + } + return s.pageStore.ListVersions(ctx, page.ID) +} + +func (s *PageService) GetVersion(ctx context.Context, workspaceSlug string, pageID, versionID, userID uuid.UUID) (*model.PageVersion, error) { + page, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return nil, err + } + v, err := s.pageStore.GetVersion(ctx, versionID) + if err != nil || v.PageID != page.ID { return nil, ErrPageNotFound } - if name != "" { - page.Name = name + return v, nil +} + +// RestoreVersion sets the page's body to the version's HTML and records a new +// version row so the restore itself is browsable history. +func (s *PageService) RestoreVersion(ctx context.Context, workspaceSlug string, pageID, versionID, userID uuid.UUID) (*model.Page, error) { + page, isMember, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) + if err != nil { + return nil, err } - if descriptionHTML != "" { - page.DescriptionHTML = descriptionHTML + if !canEditContent(page, userID, isMember) { + return nil, ErrPageReadOnly } - if access != nil { - page.Access = *access + v, err := s.pageStore.GetVersion(ctx, versionID) + if err != nil || v.PageID != page.ID { + return nil, ErrPageNotFound } - if err := s.pageStore.Update(ctx, page); err != nil { + if err := s.pageStore.UpdateContent(ctx, page.ID, v.DescriptionHTML, userID); err != nil { return nil, err } + page.DescriptionHTML = v.DescriptionHTML + page.UpdatedByID = &userID + _ = s.pageStore.CreateVersion(ctx, &model.PageVersion{ + PageID: page.ID, + WorkspaceID: page.WorkspaceID, + OwnedByID: userID, + DescriptionHTML: v.DescriptionHTML, + DescriptionStripped: stripHTML(v.DescriptionHTML), + }) return page, nil } -func (s *PageService) Delete(ctx context.Context, workspaceSlug string, pageID uuid.UUID, userID uuid.UUID) error { - _, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) +// ----- Favorites ---------------------------------------------------------- + +func (s *PageService) AddFavorite(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + page, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID) if err != nil { return err } - page, err := s.pageStore.GetByID(ctx, pageID) - if err != nil { + if s.favorites == nil { return ErrPageNotFound } - if page.OwnedByID != userID { + return s.favorites.AddPage(ctx, userID, page.WorkspaceID, nil, page.ID) +} + +func (s *PageService) RemoveFavorite(ctx context.Context, workspaceSlug string, pageID, userID uuid.UUID) error { + if _, _, err := s.loadAndCheckView(ctx, workspaceSlug, pageID, userID); err != nil { + return err + } + if s.favorites == nil { return ErrPageNotFound } - return s.pageStore.Delete(ctx, pageID) + return s.favorites.RemovePage(ctx, userID, pageID) +} + +func (s *PageService) ListFavoriteIDs(ctx context.Context, workspaceSlug string, userID uuid.UUID) ([]uuid.UUID, error) { + workspaceID, err := s.ensureWorkspaceAccess(ctx, workspaceSlug, userID) + if err != nil { + return nil, err + } + if s.favorites == nil { + return []uuid.UUID{}, nil + } + return s.favorites.ListPageIDsByUserAndWorkspace(ctx, userID, workspaceID) +} + +// ----- Helpers ------------------------------------------------------------ + +// stripHTML returns a plain-text approximation of an HTML body for search/preview. +// Cheap heuristic: drop tags + collapse whitespace. +func stripHTML(htmlContent string) string { + if htmlContent == "" { + return "" + } + var b strings.Builder + inTag := false + for _, r := range htmlContent { + switch { + case r == '<': + inTag = true + case r == '>': + inTag = false + case !inTag: + b.WriteRune(r) + } + } + return strings.Join(strings.Fields(b.String()), " ") } diff --git a/api/internal/service/page_test.go b/api/internal/service/page_test.go new file mode 100644 index 00000000..58606358 --- /dev/null +++ b/api/internal/service/page_test.go @@ -0,0 +1,79 @@ +package service + +import ( + "testing" + "time" + + "github.com/Devlaner/devlane/api/internal/model" + "github.com/google/uuid" +) + +func TestPagePermissions(t *testing.T) { + owner := uuid.MustParse("11111111-1111-1111-1111-111111111111") + other := uuid.MustParse("22222222-2222-2222-2222-222222222222") + now := time.Now() + + publicPage := &model.Page{ID: uuid.New(), OwnedByID: owner, Access: model.PageAccessPublic} + privatePage := &model.Page{ID: uuid.New(), OwnedByID: owner, Access: model.PageAccessPrivate} + lockedPublic := &model.Page{ID: uuid.New(), OwnedByID: owner, Access: model.PageAccessPublic, IsLocked: true} + archivedPublic := &model.Page{ID: uuid.New(), OwnedByID: owner, Access: model.PageAccessPublic, ArchivedAt: &now} + + tests := []struct { + name string + page *model.Page + userID uuid.UUID + isMember bool + wantView bool + wantContent bool + wantMeta bool + }{ + {"owner-public", publicPage, owner, true, true, true, true}, + {"owner-private", privatePage, owner, true, true, true, true}, + {"owner-locked-public", lockedPublic, owner, true, true, true, true}, + {"owner-archived", archivedPublic, owner, true, true, false, true}, + + // Owner who is no longer a workspace member loses all access — the + // auth boundary is workspace membership, not ownership. + {"owner-no-longer-member", publicPage, owner, false, false, false, false}, + + {"member-public", publicPage, other, true, true, true, false}, + {"member-private", privatePage, other, true, false, false, false}, + {"member-locked-public", lockedPublic, other, true, true, false, false}, + {"member-archived", archivedPublic, other, true, true, false, false}, + + {"non-member-public", publicPage, other, false, false, false, false}, + {"non-member-private", privatePage, other, false, false, false, false}, + {"non-member-locked", lockedPublic, other, false, false, false, false}, + + {"nil page", nil, owner, true, false, false, false}, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + if got := canView(tc.page, tc.userID, tc.isMember); got != tc.wantView { + t.Errorf("canView = %v; want %v", got, tc.wantView) + } + if got := canEditContent(tc.page, tc.userID, tc.isMember); got != tc.wantContent { + t.Errorf("canEditContent = %v; want %v", got, tc.wantContent) + } + if got := canEditMeta(tc.page, tc.userID, tc.isMember); got != tc.wantMeta { + t.Errorf("canEditMeta = %v; want %v", got, tc.wantMeta) + } + }) + } +} + +func TestStripHTML(t *testing.T) { + tests := map[string]string{ + "": "", + "hello world
": "hello world", + "hi there
": "hi there", + "line1
\nline2
": "line1 line2", + `tag with attr @bob
`: "tag with attr @bob", + } + for in, want := range tests { + if got := stripHTML(in); got != want { + t.Errorf("stripHTML(%q) = %q; want %q", in, got, want) + } + } +} diff --git a/api/internal/store/issue_subscriber.go b/api/internal/store/issue_subscriber.go new file mode 100644 index 00000000..d4120eed --- /dev/null +++ b/api/internal/store/issue_subscriber.go @@ -0,0 +1,60 @@ +package store + +import ( + "context" + "errors" + + "github.com/Devlaner/devlane/api/internal/model" + "github.com/google/uuid" + "gorm.io/gorm" + "gorm.io/gorm/clause" +) + +// IssueSubscriberStore handles issue_subscribers persistence. +type IssueSubscriberStore struct{ db *gorm.DB } + +func NewIssueSubscriberStore(db *gorm.DB) *IssueSubscriberStore { + return &IssueSubscriberStore{db: db} +} + +// Subscribe is idempotent — re-subscribing an already-subscribed user is a +// no-op. The DB enforces UNIQUE(issue_id, subscriber_id); ON CONFLICT DO NOTHING +// keeps us from raising on duplicates. +func (s *IssueSubscriberStore) Subscribe(ctx context.Context, sub *model.IssueSubscriber) error { + if sub == nil || sub.IssueID == uuid.Nil || sub.SubscriberID == uuid.Nil { + return errors.New("subscribe: missing issue or subscriber") + } + return s.db.WithContext(ctx). + Clauses(clause.OnConflict{ + Columns: []clause.Column{{Name: "issue_id"}, {Name: "subscriber_id"}}, + DoNothing: true, + }). + Create(sub).Error +} + +// Unsubscribe hard-deletes the subscriber row. The table has no soft-delete +// column, so this is a true DELETE. +func (s *IssueSubscriberStore) Unsubscribe(ctx context.Context, issueID, subscriberID uuid.UUID) error { + return s.db.WithContext(ctx). + Where("issue_id = ? AND subscriber_id = ?", issueID, subscriberID). + Delete(&model.IssueSubscriber{}).Error +} + +// ListByIssue returns the subscriber user IDs for an issue. +func (s *IssueSubscriberStore) ListByIssue(ctx context.Context, issueID uuid.UUID) ([]uuid.UUID, error) { + var ids []uuid.UUID + err := s.db.WithContext(ctx). + Model(&model.IssueSubscriber{}). + Where("issue_id = ?", issueID). + Pluck("subscriber_id", &ids).Error + return ids, err +} + +func (s *IssueSubscriberStore) IsSubscribed(ctx context.Context, issueID, subscriberID uuid.UUID) (bool, error) { + var n int64 + err := s.db.WithContext(ctx). + Model(&model.IssueSubscriber{}). + Where("issue_id = ? AND subscriber_id = ?", issueID, subscriberID). + Count(&n).Error + return n > 0, err +} diff --git a/api/internal/store/notification.go b/api/internal/store/notification.go index 82320356..d12f2b93 100644 --- a/api/internal/store/notification.go +++ b/api/internal/store/notification.go @@ -14,15 +14,62 @@ type NotificationStore struct{ db *gorm.DB } func NewNotificationStore(db *gorm.DB) *NotificationStore { return &NotificationStore{db: db} } -func (s *NotificationStore) ListByReceiverID(ctx context.Context, receiverID uuid.UUID, workspaceID *uuid.UUID, unreadOnly bool) ([]model.Notification, error) { +// ListOpts controls notification list filtering. +// +// Archived: nil means hide archived (default Inbox view); &false same as nil; &true shows +// only archived rows (the dedicated Archived tab). +// +// IncludeArchived overrides Archived — when true, both archived and active rows are returned. +// +// IncludeSnoozed, when false (default), hides rows whose snoozed_till is still in +// the future. The Archived tab passes true so users can manage snoozed-then-archived +// items there. +type ListOpts struct { + UnreadOnly bool + MentionsOnly bool + Archived *bool + IncludeArchived bool + IncludeSnoozed bool +} + +// Create inserts a single notification. +func (s *NotificationStore) Create(ctx context.Context, n *model.Notification) error { + return s.db.WithContext(ctx).Create(n).Error +} + +// CreateMany inserts a slice of notifications in one statement. No-op on empty input. +func (s *NotificationStore) CreateMany(ctx context.Context, ns []model.Notification) error { + if len(ns) == 0 { + return nil + } + return s.db.WithContext(ctx).Create(&ns).Error +} + +func (s *NotificationStore) ListByReceiverID(ctx context.Context, receiverID uuid.UUID, workspaceID *uuid.UUID, opts ListOpts) ([]model.Notification, error) { var list []model.Notification q := s.db.WithContext(ctx).Where("receiver_id = ?", receiverID) if workspaceID != nil { q = q.Where("workspace_id = ?", *workspaceID) } - if unreadOnly { + if opts.UnreadOnly { q = q.Where("read_at IS NULL") } + if opts.MentionsOnly { + q = q.Where("sender = ?", model.NotificationSenderMentioned) + } + if !opts.IncludeArchived { + switch { + case opts.Archived == nil: + q = q.Where("archived_at IS NULL") + case *opts.Archived: + q = q.Where("archived_at IS NOT NULL") + default: + q = q.Where("archived_at IS NULL") + } + } + if !opts.IncludeSnoozed { + q = q.Where("(snoozed_till IS NULL OR snoozed_till <= ?)", time.Now()) + } err := q.Order("created_at DESC").Limit(100).Find(&list).Error return list, err } @@ -43,11 +90,103 @@ func (s *NotificationStore) MarkRead(ctx context.Context, id uuid.UUID, receiver Update("read_at", now).Error } +func (s *NotificationStore) MarkUnread(ctx context.Context, id uuid.UUID, receiverID uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Notification{}). + Where("id = ? AND receiver_id = ?", id, receiverID). + Update("read_at", nil).Error +} + +// MarkAllRead marks every unread notification in the receiver's active inbox +// as read. "Active" mirrors List/CountUnread: not archived, not still-snoozed. +// Otherwise the user clears notifications they never saw, and snoozed rows +// would re-emerge already-read after the snooze expires. func (s *NotificationStore) MarkAllRead(ctx context.Context, receiverID uuid.UUID, workspaceID *uuid.UUID) error { now := time.Now() - q := s.db.WithContext(ctx).Model(&model.Notification{}).Where("receiver_id = ? AND read_at IS NULL", receiverID) + q := s.db.WithContext(ctx).Model(&model.Notification{}). + Where("receiver_id = ? AND read_at IS NULL AND archived_at IS NULL AND (snoozed_till IS NULL OR snoozed_till <= ?)", + receiverID, now) if workspaceID != nil { q = q.Where("workspace_id = ?", *workspaceID) } return q.Update("read_at", now).Error } + +// CountUnread returns (total, mentions) — both counts cover the active inbox +// (not archived, not still-snoozed). +// +// Postgres path uses a single query with FILTER. Other dialects (sqlite in +// tests) fall back to two queries — FILTER is Postgres-specific. +func (s *NotificationStore) CountUnread(ctx context.Context, receiverID uuid.UUID, workspaceID *uuid.UUID) (total, mentions int64, err error) { + now := time.Now() + if s.db.Dialector.Name() == "postgres" { + type row struct { + Total int64 + Mentions int64 + } + var r row + q := s.db.WithContext(ctx). + Table("notifications"). + Select("COUNT(*) AS total, COUNT(*) FILTER (WHERE sender = ?) AS mentions", model.NotificationSenderMentioned). + Where("receiver_id = ? AND read_at IS NULL AND archived_at IS NULL AND (snoozed_till IS NULL OR snoozed_till <= ?)", + receiverID, now) + if workspaceID != nil { + q = q.Where("workspace_id = ?", *workspaceID) + } + if err = q.Scan(&r).Error; err != nil { + return 0, 0, err + } + return r.Total, r.Mentions, nil + } + // Portable fallback: two COUNT(*) queries. + base := s.db.WithContext(ctx).Model(&model.Notification{}). + Where("receiver_id = ? AND read_at IS NULL AND archived_at IS NULL AND (snoozed_till IS NULL OR snoozed_till <= ?)", + receiverID, now) + if workspaceID != nil { + base = base.Where("workspace_id = ?", *workspaceID) + } + if err = base.Count(&total).Error; err != nil { + return 0, 0, err + } + if err = base.Where("sender = ?", model.NotificationSenderMentioned).Count(&mentions).Error; err != nil { + return 0, 0, err + } + return total, mentions, nil +} + +// Snooze hides a notification from the active inbox until `until`. +func (s *NotificationStore) Snooze(ctx context.Context, id, receiverID uuid.UUID, until time.Time) error { + return s.db.WithContext(ctx).Model(&model.Notification{}). + Where("id = ? AND receiver_id = ?", id, receiverID). + Update("snoozed_till", until).Error +} + +// Unsnooze clears the snoozed_till timestamp. +func (s *NotificationStore) Unsnooze(ctx context.Context, id, receiverID uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Notification{}). + Where("id = ? AND receiver_id = ?", id, receiverID). + Update("snoozed_till", nil).Error +} + +// Archive flags a notification as archived for the receiver. +func (s *NotificationStore) Archive(ctx context.Context, id, receiverID uuid.UUID) error { + now := time.Now() + return s.db.WithContext(ctx).Model(&model.Notification{}). + Where("id = ? AND receiver_id = ?", id, receiverID). + Update("archived_at", now).Error +} + +// Unarchive clears archived_at. +func (s *NotificationStore) Unarchive(ctx context.Context, id, receiverID uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Notification{}). + Where("id = ? AND receiver_id = ?", id, receiverID). + Update("archived_at", nil).Error +} + +// DeleteByEntity hard-deletes every notification referencing entityID. +// Used to garbage-collect rows when the underlying issue is deleted, so users +// don't click an Inbox row that lands on a 404. +func (s *NotificationStore) DeleteByEntity(ctx context.Context, entityID uuid.UUID) error { + return s.db.WithContext(ctx). + Where("entity_identifier = ?", entityID). + Delete(&model.Notification{}).Error +} diff --git a/api/internal/store/page.go b/api/internal/store/page.go index 240d28ff..10dbaae4 100644 --- a/api/internal/store/page.go +++ b/api/internal/store/page.go @@ -2,21 +2,129 @@ package store import ( "context" + "strings" + "time" "github.com/Devlaner/devlane/api/internal/model" "github.com/google/uuid" "gorm.io/gorm" ) -// PageStore handles page and project_page persistence. +// PageStore handles page, project_page, and page_versions persistence. type PageStore struct{ db *gorm.DB } func NewPageStore(db *gorm.DB) *PageStore { return &PageStore{db: db} } +// ListPagesOpts controls page list filtering. All fields are optional. +// +// Archived: nil hides archived (default Inbox view); &true returns only archived rows. +// ParentID: nil returns root pages only; &id returns children of that id; pass &uuid.Nil +// to mean "no parent filter — return everything". +type ListPagesOpts struct { + Archived *bool + ParentID *uuid.UUID + OwnerID *uuid.UUID + UpdatedByID *uuid.UUID + Search string + OnlyRoots bool +} + func (s *PageStore) Create(ctx context.Context, p *model.Page) error { return s.db.WithContext(ctx).Create(p).Error } +// CreateWithProjectLink inserts a page and, when projectID is non-nil, the +// matching project_pages link in a single transaction. This avoids leaving an +// orphan workspace page when the link insert fails. The page argument is +// updated in place with the generated ID. +func (s *PageStore) CreateWithProjectLink(ctx context.Context, p *model.Page, projectID *uuid.UUID, createdByID *uuid.UUID) error { + return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { + if err := tx.Create(p).Error; err != nil { + return err + } + if projectID != nil { + link := &model.ProjectPage{ + ProjectID: *projectID, + PageID: p.ID, + WorkspaceID: p.WorkspaceID, + CreatedByID: createdByID, + } + if err := tx.Create(link).Error; err != nil { + return err + } + } + return nil + }) +} + +// DuplicateInTransaction copies a page along with its project_pages links in +// one transaction. Returns the new page (updated in place). +func (s *PageStore) DuplicateInTransaction(ctx context.Context, dup *model.Page, projectIDs []uuid.UUID, createdByID *uuid.UUID) error { + return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { + if err := tx.Create(dup).Error; err != nil { + return err + } + for _, pid := range projectIDs { + link := &model.ProjectPage{ + ProjectID: pid, + PageID: dup.ID, + WorkspaceID: dup.WorkspaceID, + CreatedByID: createdByID, + } + if err := tx.Create(link).Error; err != nil { + return err + } + } + return nil + }) +} + +// ArchiveTree archives a page and all its descendants in one transaction so +// failures don't leave a partially-archived subtree behind. +func (s *PageStore) ArchiveTree(ctx context.Context, rootID uuid.UUID) error { + return s.db.WithContext(ctx).Transaction(func(tx *gorm.DB) error { + now := time.Now() + if err := tx.Model(&model.Page{}). + Where("id = ?", rootID).Update("archived_at", now).Error; err != nil { + return err + } + if tx.Dialector.Name() == "postgres" { + return tx.Exec(` + WITH RECURSIVE descendants AS ( + SELECT id FROM pages WHERE parent_id = ? AND deleted_at IS NULL + UNION ALL + SELECT p.id FROM pages p + JOIN descendants d ON p.parent_id = d.id + WHERE p.deleted_at IS NULL + ) + UPDATE pages SET archived_at = NOW(), updated_at = NOW() + WHERE id IN (SELECT id FROM descendants) AND archived_at IS NULL + `, rootID).Error + } + // Iterative fallback for non-Postgres (sqlite tests). + queue := []uuid.UUID{rootID} + for len(queue) > 0 { + next := queue[0] + queue = queue[1:] + var children []model.Page + if err := tx. + Where("parent_id = ? AND deleted_at IS NULL", next).Find(&children).Error; err != nil { + return err + } + for _, c := range children { + if c.ArchivedAt == nil { + if err := tx.Model(&model.Page{}). + Where("id = ?", c.ID).Update("archived_at", now).Error; err != nil { + return err + } + } + queue = append(queue, c.ID) + } + } + return nil + }) +} + func (s *PageStore) GetByID(ctx context.Context, id uuid.UUID) (*model.Page, error) { var page model.Page err := s.db.WithContext(ctx).Where("id = ? AND deleted_at IS NULL", id).First(&page).Error @@ -26,22 +134,45 @@ func (s *PageStore) GetByID(ctx context.Context, id uuid.UUID) (*model.Page, err return &page, nil } -func (s *PageStore) ListByWorkspaceID(ctx context.Context, workspaceID uuid.UUID) ([]model.Page, error) { +// ListByWorkspaceID returns workspace-scoped pages with optional filters. +func (s *PageStore) ListByWorkspaceID(ctx context.Context, workspaceID uuid.UUID, opts ListPagesOpts) ([]model.Page, error) { + q := s.db.WithContext(ctx).Where("workspace_id = ? AND deleted_at IS NULL", workspaceID) + q = applyPageFilters(q, opts) var list []model.Page - err := s.db.WithContext(ctx).Where("workspace_id = ? AND deleted_at IS NULL", workspaceID). - Order("sort_order ASC, created_at ASC").Find(&list).Error + err := q.Order("sort_order ASC, created_at ASC").Find(&list).Error return list, err } -func (s *PageStore) ListByProjectID(ctx context.Context, projectID uuid.UUID) ([]model.Page, error) { - var list []model.Page - err := s.db.WithContext(ctx).Model(&model.Page{}). +// ListByProjectID returns pages linked to the given project, with optional filters. +func (s *PageStore) ListByProjectID(ctx context.Context, projectID uuid.UUID, opts ListPagesOpts) ([]model.Page, error) { + q := s.db.WithContext(ctx).Model(&model.Page{}). Joins("INNER JOIN project_pages ON project_pages.page_id = pages.id AND project_pages.deleted_at IS NULL"). - Where("project_pages.project_id = ? AND pages.deleted_at IS NULL", projectID). - Order("pages.sort_order ASC, pages.created_at ASC").Find(&list).Error + Where("project_pages.project_id = ? AND pages.deleted_at IS NULL", projectID) + q = applyPageFilters(q, opts) + var list []model.Page + err := q.Order("pages.sort_order ASC, pages.created_at ASC").Find(&list).Error + return list, err +} + +// ListChildrenByParentID returns the immediate children of a page. +func (s *PageStore) ListChildrenByParentID(ctx context.Context, parentID uuid.UUID) ([]model.Page, error) { + var list []model.Page + err := s.db.WithContext(ctx). + Where("parent_id = ? AND deleted_at IS NULL", parentID). + Order("sort_order ASC, created_at ASC"). + Find(&list).Error return list, err } +// ListProjectIDsForPage returns the project IDs a page is linked to. +func (s *PageStore) ListProjectIDsForPage(ctx context.Context, pageID uuid.UUID) ([]uuid.UUID, error) { + var ids []uuid.UUID + err := s.db.WithContext(ctx).Model(&model.ProjectPage{}). + Where("page_id = ? AND deleted_at IS NULL", pageID). + Pluck("project_id", &ids).Error + return ids, err +} + func (s *PageStore) Update(ctx context.Context, p *model.Page) error { return s.db.WithContext(ctx).Save(p).Error } @@ -50,6 +181,89 @@ func (s *PageStore) Delete(ctx context.Context, id uuid.UUID) error { return s.db.WithContext(ctx).Where("id = ?", id).Delete(&model.Page{}).Error } +func (s *PageStore) Lock(ctx context.Context, id uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id).Update("is_locked", true).Error +} + +func (s *PageStore) Unlock(ctx context.Context, id uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id).Update("is_locked", false).Error +} + +func (s *PageStore) Archive(ctx context.Context, id uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id).Update("archived_at", time.Now()).Error +} + +func (s *PageStore) Unarchive(ctx context.Context, id uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id).Update("archived_at", nil).Error +} + +// ArchiveDescendants archives all descendants of rootID via a recursive CTE. +// Postgres-specific. Returns nil on non-Postgres dialects (test setup uses sqlite). +func (s *PageStore) ArchiveDescendants(ctx context.Context, rootID uuid.UUID) error { + if s.db.Dialector.Name() != "postgres" { + // Sqlite (used by tests) doesn't support recursive CTE updates the same way. + // Walk the tree iteratively as a fallback. + return s.archiveDescendantsIterative(ctx, rootID) + } + return s.db.WithContext(ctx).Exec(` + WITH RECURSIVE descendants AS ( + SELECT id FROM pages WHERE parent_id = ? AND deleted_at IS NULL + UNION ALL + SELECT p.id FROM pages p + JOIN descendants d ON p.parent_id = d.id + WHERE p.deleted_at IS NULL + ) + UPDATE pages SET archived_at = NOW(), updated_at = NOW() + WHERE id IN (SELECT id FROM descendants) AND archived_at IS NULL + `, rootID).Error +} + +func (s *PageStore) archiveDescendantsIterative(ctx context.Context, rootID uuid.UUID) error { + now := time.Now() + queue := []uuid.UUID{rootID} + for len(queue) > 0 { + next := queue[0] + queue = queue[1:] + var children []model.Page + if err := s.db.WithContext(ctx). + Where("parent_id = ? AND deleted_at IS NULL", next).Find(&children).Error; err != nil { + return err + } + for _, c := range children { + if c.ArchivedAt == nil { + if err := s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", c.ID).Update("archived_at", now).Error; err != nil { + return err + } + } + queue = append(queue, c.ID) + } + } + return nil +} + +// SetAccess sets a page's access level (0 public, 1 private). Caller enforces ownership. +func (s *PageStore) SetAccess(ctx context.Context, id uuid.UUID, access int16) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id).Update("access", access).Error +} + +// UpdateContent updates a page's HTML body and stamps updated_by_id/updated_at. +// Caller is responsible for enforcing edit permissions and recording a version row. +func (s *PageStore) UpdateContent(ctx context.Context, id uuid.UUID, html string, updatedByID uuid.UUID) error { + return s.db.WithContext(ctx).Model(&model.Page{}). + Where("id = ?", id). + Updates(map[string]any{ + "description_html": html, + "updated_by_id": updatedByID, + "updated_at": time.Now(), + }).Error +} + func (s *PageStore) AddProjectPage(ctx context.Context, pp *model.ProjectPage) error { return s.db.WithContext(ctx).Create(pp).Error } @@ -58,3 +272,55 @@ func (s *PageStore) RemoveProjectPage(ctx context.Context, projectID, pageID uui return s.db.WithContext(ctx).Where("project_id = ? AND page_id = ?", projectID, pageID). Delete(&model.ProjectPage{}).Error } + +// ----- Page versions ----- + +func (s *PageStore) CreateVersion(ctx context.Context, v *model.PageVersion) error { + return s.db.WithContext(ctx).Create(v).Error +} + +func (s *PageStore) ListVersions(ctx context.Context, pageID uuid.UUID) ([]model.PageVersion, error) { + var list []model.PageVersion + err := s.db.WithContext(ctx). + Where("page_id = ?", pageID). + Order("last_saved_at DESC"). + Find(&list).Error + return list, err +} + +func (s *PageStore) GetVersion(ctx context.Context, versionID uuid.UUID) (*model.PageVersion, error) { + var v model.PageVersion + err := s.db.WithContext(ctx).Where("id = ?", versionID).First(&v).Error + if err != nil { + return nil, err + } + return &v, nil +} + +// ----- Helpers ----- + +func applyPageFilters(q *gorm.DB, opts ListPagesOpts) *gorm.DB { + switch { + case opts.Archived == nil: + q = q.Where("pages.archived_at IS NULL") + case *opts.Archived: + q = q.Where("pages.archived_at IS NOT NULL") + default: + q = q.Where("pages.archived_at IS NULL") + } + if opts.OnlyRoots { + q = q.Where("pages.parent_id IS NULL") + } else if opts.ParentID != nil && *opts.ParentID != uuid.Nil { + q = q.Where("pages.parent_id = ?", *opts.ParentID) + } + if opts.OwnerID != nil { + q = q.Where("pages.owned_by_id = ?", *opts.OwnerID) + } + if opts.UpdatedByID != nil { + q = q.Where("pages.updated_by_id = ?", *opts.UpdatedByID) + } + if s := strings.TrimSpace(opts.Search); s != "" { + q = q.Where("LOWER(pages.name) LIKE ?", "%"+strings.ToLower(s)+"%") + } + return q +} diff --git a/api/internal/store/user_favorite.go b/api/internal/store/user_favorite.go index 537e8ce8..194f6d82 100644 --- a/api/internal/store/user_favorite.go +++ b/api/internal/store/user_favorite.go @@ -14,6 +14,9 @@ const FavoriteEntityTypeProject = "project" // FavoriteEntityTypeIssueView is stored in user_favorites.entity_type for saved issue views. const FavoriteEntityTypeIssueView = "issue_view" +// FavoriteEntityTypePage is stored in user_favorites.entity_type for project pages. +const FavoriteEntityTypePage = "page" + // UserFavoriteStore handles user_favorites persistence. type UserFavoriteStore struct{ db *gorm.DB } @@ -96,3 +99,45 @@ func (s *UserFavoriteStore) IsIssueViewFavorited(ctx context.Context, userID, vi Count(&count).Error return count > 0, err } + +// ListPageIDsByUserAndWorkspace returns page IDs the user has favorited in a workspace. +func (s *UserFavoriteStore) ListPageIDsByUserAndWorkspace(ctx context.Context, userID, workspaceID uuid.UUID) ([]uuid.UUID, error) { + var ids []uuid.UUID + err := s.db.WithContext(ctx).Model(&model.UserFavorite{}). + Where("user_id = ? AND entity_type = ? AND workspace_id = ?", userID, FavoriteEntityTypePage, workspaceID). + Pluck("entity_identifier", &ids).Error + return ids, err +} + +// AddPage favorites a page for the user. Idempotent on conflict. +func (s *UserFavoriteStore) AddPage(ctx context.Context, userID, workspaceID uuid.UUID, projectID *uuid.UUID, pageID uuid.UUID) error { + fav := &model.UserFavorite{ + Name: "page", + Type: "page", + EntityType: FavoriteEntityTypePage, + EntityIdentifier: pageID, + WorkspaceID: workspaceID, + ProjectID: projectID, + UserID: userID, + } + return s.db.WithContext(ctx).Clauses(clause.OnConflict{ + Columns: []clause.Column{{Name: "user_id"}, {Name: "entity_type"}, {Name: "entity_identifier"}}, + DoNothing: true, + }).Create(fav).Error +} + +// RemovePage removes a page from the user's favorites. +func (s *UserFavoriteStore) RemovePage(ctx context.Context, userID, pageID uuid.UUID) error { + return s.db.WithContext(ctx). + Where("user_id = ? AND entity_type = ? AND entity_identifier = ?", userID, FavoriteEntityTypePage, pageID). + Delete(&model.UserFavorite{}).Error +} + +// IsPageFavorited reports whether the user has favorited the given page. +func (s *UserFavoriteStore) IsPageFavorited(ctx context.Context, userID, pageID uuid.UUID) (bool, error) { + var count int64 + err := s.db.WithContext(ctx).Model(&model.UserFavorite{}). + Where("user_id = ? AND entity_type = ? AND entity_identifier = ?", userID, FavoriteEntityTypePage, pageID). + Count(&count).Error + return count > 0, err +} diff --git a/api/internal/text/mentions.go b/api/internal/text/mentions.go new file mode 100644 index 00000000..e97679d0 --- /dev/null +++ b/api/internal/text/mentions.go @@ -0,0 +1,65 @@ +// Package text contains helpers for parsing rich-text content stored as HTML +// in issue descriptions and comments. +package text + +import ( + "strings" + + "github.com/google/uuid" + "golang.org/x/net/html" +) + +// ParseMentionUserIDs extracts the deduplicated set of user IDs referenced by +// the editor's mention extension. Mentions serialize as +// @Label. +// +// IDs that fail uuid.Parse are dropped silently. Returns nil for empty/invalid input. +func ParseMentionUserIDs(htmlContent string) []uuid.UUID { + htmlContent = strings.TrimSpace(htmlContent) + if htmlContent == "" { + return nil + } + z := html.NewTokenizer(strings.NewReader(htmlContent)) + seen := make(map[uuid.UUID]struct{}) + out := make([]uuid.UUID, 0, 4) + for { + tt := z.Next() + switch tt { + case html.ErrorToken: + return out + case html.StartTagToken, html.SelfClosingTagToken: + name, hasAttr := z.TagName() + if string(name) != "span" || !hasAttr { + continue + } + isMention := false + var dataID string + for { + attrName, attrVal, more := z.TagAttr() + switch string(attrName) { + case "data-type": + if string(attrVal) == "mention" { + isMention = true + } + case "data-id": + dataID = string(attrVal) + } + if !more { + break + } + } + if !isMention || dataID == "" { + continue + } + id, err := uuid.Parse(dataID) + if err != nil { + continue + } + if _, dup := seen[id]; dup { + continue + } + seen[id] = struct{}{} + out = append(out, id) + } + } +} diff --git a/api/internal/text/mentions_test.go b/api/internal/text/mentions_test.go new file mode 100644 index 00000000..68ebf711 --- /dev/null +++ b/api/internal/text/mentions_test.go @@ -0,0 +1,74 @@ +package text + +import ( + "testing" + + "github.com/google/uuid" +) + +func TestParseMentionUserIDs(t *testing.T) { + alice := uuid.MustParse("11111111-1111-1111-1111-111111111111") + bob := uuid.MustParse("22222222-2222-2222-2222-222222222222") + + tests := []struct { + name string + in string + want []uuid.UUID + }{ + { + name: "empty", + in: "", + want: nil, + }, + { + name: "plain text without mentions", + in: "just a comment with @username typed as plain text
", + want: []uuid.UUID{}, + }, + { + name: "single tiptap mention", + in: `hey @Alice please review
`, + want: []uuid.UUID{alice}, + }, + { + name: "two mentions deduped", + in: `@Alice + @Bob + @Alice
`, + want: []uuid.UUID{alice, bob}, + }, + { + name: "non-mention spans ignored", + in: `@fake not a real mention
`, + want: []uuid.UUID{}, + }, + { + name: "malformed UUID dropped", + in: `@x
`, + want: []uuid.UUID{}, + }, + { + name: "mention nested in formatting", + in: `@Bob
`, + want: []uuid.UUID{bob}, + }, + } + + for _, tc := range tests { + t.Run(tc.name, func(t *testing.T) { + got := ParseMentionUserIDs(tc.in) + if len(got) != len(tc.want) { + t.Fatalf("len mismatch: got %v, want %v", got, tc.want) + } + gotSet := make(map[uuid.UUID]bool, len(got)) + for _, id := range got { + gotSet[id] = true + } + for _, id := range tc.want { + if !gotSet[id] { + t.Errorf("missing %s; got %v", id, got) + } + } + }) + } +} diff --git a/package-lock.json b/package-lock.json index 4037fa05..d7bdf22d 100644 --- a/package-lock.json +++ b/package-lock.json @@ -1,12 +1,12 @@ { "name": "devlane", - "version": "1.1.0", + "version": "1.2.1", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "devlane", - "version": "1.1.0", + "version": "1.2.1", "license": "ISC", "devDependencies": { "@commitlint/cli": "^19.8.1", diff --git a/package.json b/package.json index 1f15bb2c..b540689d 100644 --- a/package.json +++ b/package.json @@ -1,6 +1,6 @@ { "name": "devlane", - "version": "1.1.0", + "version": "1.2.1", "private": true, "description": "", "main": "index.js", diff --git a/ui/package-lock.json b/ui/package-lock.json index 321380d7..b7e10026 100644 --- a/ui/package-lock.json +++ b/ui/package-lock.json @@ -1,22 +1,31 @@ { "name": "Devlane UI", - "version": "0.6.0", + "version": "0.7.3", "lockfileVersion": 3, "requires": true, "packages": { "": { "name": "Devlane UI", - "version": "0.6.0", + "version": "0.7.3", "dependencies": { "@headlessui/react": "^2.2.9", "@tailwindcss/vite": "^4.1.18", "@tiptap/core": "3.22.3", + "@tiptap/extension-color": "3.22.3", + "@tiptap/extension-highlight": "3.22.3", + "@tiptap/extension-image": "3.22.3", "@tiptap/extension-link": "3.22.3", "@tiptap/extension-list": "3.22.3", "@tiptap/extension-mention": "^3.22.3", "@tiptap/extension-placeholder": "3.22.3", + "@tiptap/extension-table": "3.22.3", + "@tiptap/extension-table-cell": "3.22.3", + "@tiptap/extension-table-header": "3.22.3", + "@tiptap/extension-table-row": "3.22.3", "@tiptap/extension-task-item": "3.22.3", "@tiptap/extension-task-list": "3.22.3", + "@tiptap/extension-text-align": "3.22.3", + "@tiptap/extension-text-style": "3.22.3", "@tiptap/extension-underline": "3.22.3", "@tiptap/pm": "3.22.3", "@tiptap/react": "3.22.3", @@ -2184,6 +2193,19 @@ "@tiptap/pm": "^3.22.3" } }, + "node_modules/@tiptap/extension-color": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-color/-/extension-color-3.22.3.tgz", + "integrity": "sha512-eZtOc4Zp5jnlZh4+gvr3JmOa3kPlIU8IbTByDMgXEMdVGZ5cOk+H4TMIlhU0j7j1TMWm8+r1WYtrU9E9ooz9hQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/extension-text-style": "^3.22.3" + } + }, "node_modules/@tiptap/extension-document": { "version": "3.22.3", "resolved": "https://registry.npmjs.org/@tiptap/extension-document/-/extension-document-3.22.3.tgz", @@ -2265,6 +2287,19 @@ "@tiptap/core": "^3.22.3" } }, + "node_modules/@tiptap/extension-highlight": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-highlight/-/extension-highlight-3.22.3.tgz", + "integrity": "sha512-iGDzQ3IuVQpfQcWsMEQ0B8q3R83bZZH6l6O2MuCmWbzm/p7mMi5vQwRCMLAbM9xFELq8KjDMHOWeER4fozp/Sg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/core": "^3.22.3" + } + }, "node_modules/@tiptap/extension-horizontal-rule": { "version": "3.22.3", "resolved": "https://registry.npmjs.org/@tiptap/extension-horizontal-rule/-/extension-horizontal-rule-3.22.3.tgz", @@ -2279,6 +2314,19 @@ "@tiptap/pm": "^3.22.3" } }, + "node_modules/@tiptap/extension-image": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-image/-/extension-image-3.22.3.tgz", + "integrity": "sha512-Qpp8c5LOQaNpHrzjqZtoxtIR+8sSqJ7k8v+8anmYw3nxjvt2kpfT28Vd7aWMX55ZS43LaxMx+MkZqbmgUmMP0w==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/core": "^3.22.3" + } + }, "node_modules/@tiptap/extension-italic": { "version": "3.22.3", "resolved": "https://registry.npmjs.org/@tiptap/extension-italic/-/extension-italic-3.22.3.tgz", @@ -2416,6 +2464,59 @@ "@tiptap/core": "^3.22.3" } }, + "node_modules/@tiptap/extension-table": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-table/-/extension-table-3.22.3.tgz", + "integrity": "sha512-inbQSusJad7H0T++L1APg/anfL5d15cNGp2YG3vwo6TQr71nn2c9pepvmz3xuAIt8eygZDRba+4GT/COP1f9QA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/core": "^3.22.3", + "@tiptap/pm": "^3.22.3" + } + }, + "node_modules/@tiptap/extension-table-cell": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-table-cell/-/extension-table-cell-3.22.3.tgz", + "integrity": "sha512-LgaUgNwjHe6J7dq66N7iflC9efjgygsYWkHJtfLzaSU82tXzk8HSwBrMRCaj0PU+AR967/jGixEZIxH9xfXswQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/extension-table": "^3.22.3" + } + }, + "node_modules/@tiptap/extension-table-header": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-table-header/-/extension-table-header-3.22.3.tgz", + "integrity": "sha512-5wQ5rne9ccdbzeqC1AEDaUzlWjnpQNgBctgSPKEv+Da88lRRcGX21H+b/8jhL7fr4/sznr45toKGUg8NmRhboQ==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/extension-table": "^3.22.3" + } + }, + "node_modules/@tiptap/extension-table-row": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-table-row/-/extension-table-row-3.22.3.tgz", + "integrity": "sha512-dkoHnbOZgb2iQLXsp2FUu0KejAh3LOqDLMixYYU/0lnUwhqGG8kgu6+0YkCiUhedbfMFqVvemdKnRddpTQ4sqg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/extension-table": "^3.22.3" + } + }, "node_modules/@tiptap/extension-task-item": { "version": "3.22.3", "resolved": "https://registry.npmjs.org/@tiptap/extension-task-item/-/extension-task-item-3.22.3.tgz", @@ -2455,6 +2556,32 @@ "@tiptap/core": "^3.22.3" } }, + "node_modules/@tiptap/extension-text-align": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-text-align/-/extension-text-align-3.22.3.tgz", + "integrity": "sha512-dG1NHE0yGf7fYiOdabCJuecI2IJ1uogyY/QvZqvPNaxRjZDoXYuGlMtz9jEDiIdQSaPED2MSsS7KkuNFQIEMGg==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/core": "^3.22.3" + } + }, + "node_modules/@tiptap/extension-text-style": { + "version": "3.22.3", + "resolved": "https://registry.npmjs.org/@tiptap/extension-text-style/-/extension-text-style-3.22.3.tgz", + "integrity": "sha512-JKmWAogM/LX9ZJmXJQalpcR77wWVtVXdRFgvHGsFomW9WFhZqcnIEDWR2sbpZHWtu8dml6eBQGhdLppJmxeFfA==", + "license": "MIT", + "funding": { + "type": "github", + "url": "https://github.com/sponsors/ueberdosis" + }, + "peerDependencies": { + "@tiptap/core": "^3.22.3" + } + }, "node_modules/@tiptap/extension-underline": { "version": "3.22.3", "resolved": "https://registry.npmjs.org/@tiptap/extension-underline/-/extension-underline-3.22.3.tgz", diff --git a/ui/package.json b/ui/package.json index 6158f637..5bc2318b 100644 --- a/ui/package.json +++ b/ui/package.json @@ -1,7 +1,7 @@ { "name": "Devlane UI", "private": true, - "version": "0.6.0", + "version": "0.7.3", "type": "module", "scripts": { "dev": "vite", @@ -17,12 +17,21 @@ "@headlessui/react": "^2.2.9", "@tailwindcss/vite": "^4.1.18", "@tiptap/core": "3.22.3", + "@tiptap/extension-color": "3.22.3", + "@tiptap/extension-highlight": "3.22.3", + "@tiptap/extension-image": "3.22.3", "@tiptap/extension-link": "3.22.3", "@tiptap/extension-list": "3.22.3", "@tiptap/extension-mention": "^3.22.3", "@tiptap/extension-placeholder": "3.22.3", + "@tiptap/extension-table": "3.22.3", + "@tiptap/extension-table-cell": "3.22.3", + "@tiptap/extension-table-header": "3.22.3", + "@tiptap/extension-table-row": "3.22.3", "@tiptap/extension-task-item": "3.22.3", "@tiptap/extension-task-list": "3.22.3", + "@tiptap/extension-text-align": "3.22.3", + "@tiptap/extension-text-style": "3.22.3", "@tiptap/extension-underline": "3.22.3", "@tiptap/pm": "3.22.3", "@tiptap/react": "3.22.3", diff --git a/ui/src/api/types.ts b/ui/src/api/types.ts index 2f823cff..0a725407 100644 --- a/ui/src/api/types.ts +++ b/ui/src/api/types.ts @@ -601,7 +601,6 @@ export interface IssueViewApiResponse { display_properties?: Record