appview/{models,db}: notifications tables, models and helpers #589

+31 -1

appview/db/db.go

··· 530 530 unique (repo_at, label_at) 531 531 ); 532 532 533 533 + create table if not exists notifications ( 534 534 + id integer primary key autoincrement, 535 535 + recipient_did text not null, 536 536 + actor_did text not null, 537 537 + type text not null, 538 538 + entity_type text not null, 539 539 + entity_id text not null, 540 540 + read integer not null default 0, 541 541 + created text not null default (strftime('%Y-%m-%dT%H:%M:%SZ', 'now')), 542 542 + repo_id integer references repos(id), 543 543 + issue_id integer references issues(id), 544 544 + pull_id integer references pulls(id) 545 545 + ); 546 546 + 547 547 + create table if not exists notification_preferences ( 548 548 + id integer primary key autoincrement, 549 549 + user_did text not null unique, 550 550 + repo_starred integer not null default 1, 551 551 + issue_created integer not null default 1, 552 552 + issue_commented integer not null default 1, 553 553 + pull_created integer not null default 1, 554 554 + pull_commented integer not null default 1, 555 555 + followed integer not null default 1, 556 556 + pull_merged integer not null default 1, 557 557 + issue_closed integer not null default 1, 558 558 + email_notifications integer not null default 0 559 559 + ); 560 560 + 533 561 create table if not exists migrations ( 534 562 id integer primary key autoincrement, 535 563 name text unique 536 564 ); 537 565 538 538 - -- indexes for better star query performance 566 566 + -- indexes for better performance 567 567 + create index if not exists idx_notifications_recipient_created on notifications(recipient_did, created desc); 568 568 + create index if not exists idx_notifications_recipient_read on notifications(recipient_did, read); 539 569 create index if not exists idx_stars_created on stars(created); 540 570 create index if not exists idx_stars_repo_at_created on stars(repo_at, created); 541 571 `)

+457

appview/db/notifications.go

··· 1 1 + package db 2 2 + 3 3 + import ( 4 4 + "context" 5 5 + "database/sql" 6 6 + "fmt" 7 7 + "time" 8 8 + 9 9 + "tangled.org/core/appview/models" 10 10 + "tangled.org/core/appview/pagination" 11 11 + ) 12 12 + 13 13 + func (d *DB) CreateNotification(ctx context.Context, notification *models.Notification) error { 14 14 + query := ` 15 15 + INSERT INTO notifications (recipient_did, actor_did, type, entity_type, entity_id, read, repo_id, issue_id, pull_id) 16 16 + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?) 17 17 + ` 18 18 + 19 19 + result, err := d.DB.ExecContext(ctx, query, 20 20 + notification.RecipientDid, 21 21 + notification.ActorDid, 22 22 + string(notification.Type), 23 23 + notification.EntityType, 24 24 + notification.EntityId, 25 25 + notification.Read, 26 26 + notification.RepoId, 27 27 + notification.IssueId, 28 28 + notification.PullId, 29 29 + ) 30 30 + if err != nil { 31 31 + return fmt.Errorf("failed to create notification: %w", err) 32 32 + } 33 33 + 34 34 + id, err := result.LastInsertId() 35 35 + if err != nil { 36 36 + return fmt.Errorf("failed to get notification ID: %w", err) 37 37 + } 38 38 + 39 39 + notification.ID = id 40 40 + return nil 41 41 + } 42 42 + 43 43 + // GetNotificationsPaginated retrieves notifications with filters and pagination 44 44 + func GetNotificationsPaginated(e Execer, page pagination.Page, filters ...filter) ([]*models.Notification, error) { 45 45 + var conditions []string 46 46 + var args []any 47 47 + 48 48 + for _, filter := range filters { 49 49 + conditions = append(conditions, filter.Condition()) 50 50 + args = append(args, filter.Arg()...) 51 51 + } 52 52 + 53 53 + whereClause := "" 54 54 + if len(conditions) > 0 { 55 55 + whereClause = "WHERE " + conditions[0] 56 56 + for _, condition := range conditions[1:] { 57 57 + whereClause += " AND " + condition 58 58 + } 59 59 + } 60 60 + 61 61 + query := fmt.Sprintf(` 62 62 + select id, recipient_did, actor_did, type, entity_type, entity_id, read, created, repo_id, issue_id, pull_id 63 63 + from notifications 64 64 + %s 65 65 + order by created desc 66 66 + limit ? offset ? 67 67 + `, whereClause) 68 68 + 69 69 + args = append(args, page.Limit, page.Offset) 70 70 + 71 71 + rows, err := e.QueryContext(context.Background(), query, args...) 72 72 + if err != nil { 73 73 + return nil, fmt.Errorf("failed to query notifications: %w", err) 74 74 + } 75 75 + defer rows.Close() 76 76 + 77 77 + var notifications []*models.Notification 78 78 + for rows.Next() { 79 79 + var n models.Notification 80 80 + var typeStr string 81 81 + var createdStr string 82 82 + err := rows.Scan( 83 83 + &n.ID, 84 84 + &n.RecipientDid, 85 85 + &n.ActorDid, 86 86 + &typeStr, 87 87 + &n.EntityType, 88 88 + &n.EntityId, 89 89 + &n.Read, 90 90 + &createdStr, 91 91 + &n.RepoId, 92 92 + &n.IssueId, 93 93 + &n.PullId, 94 94 + ) 95 95 + if err != nil { 96 96 + return nil, fmt.Errorf("failed to scan notification: %w", err) 97 97 + } 98 98 + n.Type = models.NotificationType(typeStr) 99 99 + n.Created, err = time.Parse(time.RFC3339, createdStr) 100 100 + if err != nil { 101 101 + return nil, fmt.Errorf("failed to parse created timestamp: %w", err) 102 102 + } 103 103 + notifications = append(notifications, &n) 104 104 + } 105 105 + 106 106 + return notifications, nil 107 107 + } 108 108 + 109 109 + // GetNotificationsWithEntities retrieves notifications with their related entities 110 110 + func GetNotificationsWithEntities(e Execer, page pagination.Page, filters ...filter) ([]*models.NotificationWithEntity, error) { 111 111 + var conditions []string 112 112 + var args []any 113 113 + 114 114 + for _, filter := range filters { 115 115 + conditions = append(conditions, filter.Condition()) 116 116 + args = append(args, filter.Arg()...) 117 117 + } 118 118 + 119 119 + whereClause := "" 120 120 + if len(conditions) > 0 { 121 121 + whereClause = "WHERE " + conditions[0] 122 122 + for _, condition := range conditions[1:] { 123 123 + whereClause += " AND " + condition 124 124 + } 125 125 + } 126 126 + 127 127 + query := fmt.Sprintf(` 128 128 + select 129 129 + n.id, n.recipient_did, n.actor_did, n.type, n.entity_type, n.entity_id, 130 130 + n.read, n.created, n.repo_id, n.issue_id, n.pull_id, 131 131 + r.id as r_id, r.did as r_did, r.name as r_name, r.description as r_description, 132 132 + i.id as i_id, i.did as i_did, i.issue_id as i_issue_id, i.title as i_title, i.open as i_open, 133 133 + p.id as p_id, p.owner_did as p_owner_did, p.pull_id as p_pull_id, p.title as p_title, p.state as p_state 134 134 + from notifications n 135 135 + left join repos r on n.repo_id = r.id 136 136 + left join issues i on n.issue_id = i.id 137 137 + left join pulls p on n.pull_id = p.id 138 138 + %s 139 139 + order by n.created desc 140 140 + limit ? offset ? 141 141 + `, whereClause) 142 142 + 143 143 + args = append(args, page.Limit, page.Offset) 144 144 + 145 145 + rows, err := e.QueryContext(context.Background(), query, args...) 146 146 + if err != nil { 147 147 + return nil, fmt.Errorf("failed to query notifications with entities: %w", err) 148 148 + } 149 149 + defer rows.Close() 150 150 + 151 151 + var notifications []*models.NotificationWithEntity 152 152 + for rows.Next() { 153 153 + var n models.Notification 154 154 + var typeStr string 155 155 + var createdStr string 156 156 + var repo models.Repo 157 157 + var issue models.Issue 158 158 + var pull models.Pull 159 159 + var rId, iId, pId sql.NullInt64 160 160 + var rDid, rName, rDescription sql.NullString 161 161 + var iDid sql.NullString 162 162 + var iIssueId sql.NullInt64 163 163 + var iTitle sql.NullString 164 164 + var iOpen sql.NullBool 165 165 + var pOwnerDid sql.NullString 166 166 + var pPullId sql.NullInt64 167 167 + var pTitle sql.NullString 168 168 + var pState sql.NullInt64 169 169 + 170 170 + err := rows.Scan( 171 171 + &n.ID, &n.RecipientDid, &n.ActorDid, &typeStr, &n.EntityType, &n.EntityId, 172 172 + &n.Read, &createdStr, &n.RepoId, &n.IssueId, &n.PullId, 173 173 + &rId, &rDid, &rName, &rDescription, 174 174 + &iId, &iDid, &iIssueId, &iTitle, &iOpen, 175 175 + &pId, &pOwnerDid, &pPullId, &pTitle, &pState, 176 176 + ) 177 177 + if err != nil { 178 178 + return nil, fmt.Errorf("failed to scan notification with entities: %w", err) 179 179 + } 180 180 + 181 181 + n.Type = models.NotificationType(typeStr) 182 182 + n.Created, err = time.Parse(time.RFC3339, createdStr) 183 183 + if err != nil { 184 184 + return nil, fmt.Errorf("failed to parse created timestamp: %w", err) 185 185 + } 186 186 + 187 187 + nwe := &models.NotificationWithEntity{Notification: &n} 188 188 + 189 189 + // populate repo if present 190 190 + if rId.Valid { 191 191 + repo.Id = rId.Int64 192 192 + if rDid.Valid { 193 193 + repo.Did = rDid.String 194 194 + } 195 195 + if rName.Valid { 196 196 + repo.Name = rName.String 197 197 + } 198 198 + if rDescription.Valid { 199 199 + repo.Description = rDescription.String 200 200 + } 201 201 + nwe.Repo = &repo 202 202 + } 203 203 + 204 204 + // populate issue if present 205 205 + if iId.Valid { 206 206 + issue.Id = iId.Int64 207 207 + if iDid.Valid { 208 208 + issue.Did = iDid.String 209 209 + } 210 210 + if iIssueId.Valid { 211 211 + issue.IssueId = int(iIssueId.Int64) 212 212 + } 213 213 + if iTitle.Valid { 214 214 + issue.Title = iTitle.String 215 215 + } 216 216 + if iOpen.Valid { 217 217 + issue.Open = iOpen.Bool 218 218 + } 219 219 + nwe.Issue = &issue 220 220 + } 221 221 + 222 222 + // populate pull if present 223 223 + if pId.Valid { 224 224 + pull.ID = int(pId.Int64) 225 225 + if pOwnerDid.Valid { 226 226 + pull.OwnerDid = pOwnerDid.String 227 227 + } 228 228 + if pPullId.Valid { 229 229 + pull.PullId = int(pPullId.Int64) 230 230 + } 231 231 + if pTitle.Valid { 232 232 + pull.Title = pTitle.String 233 233 + } 234 234 + if pState.Valid { 235 235 + pull.State = models.PullState(pState.Int64) 236 236 + } 237 237 + nwe.Pull = &pull 238 238 + } 239 239 + 240 240 + notifications = append(notifications, nwe) 241 241 + } 242 242 + 243 243 + return notifications, nil 244 244 + } 245 245 + 246 246 + // GetNotifications retrieves notifications with filters 247 247 + func GetNotifications(e Execer, filters ...filter) ([]*models.Notification, error) { 248 248 + return GetNotificationsPaginated(e, pagination.FirstPage(), filters...) 249 249 + } 250 250 + 251 251 + // GetNotifications retrieves notifications for a user with pagination (legacy method for backward compatibility) 252 252 + func (d *DB) GetNotifications(ctx context.Context, userDID string, limit, offset int) ([]*models.Notification, error) { 253 253 + page := pagination.Page{Limit: limit, Offset: offset} 254 254 + return GetNotificationsPaginated(d.DB, page, FilterEq("recipient_did", userDID)) 255 255 + } 256 256 + 257 257 + // GetNotificationsWithEntities retrieves notifications with entities for a user with pagination 258 258 + func (d *DB) GetNotificationsWithEntities(ctx context.Context, userDID string, limit, offset int) ([]*models.NotificationWithEntity, error) { 259 259 + page := pagination.Page{Limit: limit, Offset: offset} 260 260 + return GetNotificationsWithEntities(d.DB, page, FilterEq("recipient_did", userDID)) 261 261 + } 262 262 + 263 263 + func (d *DB) GetUnreadNotificationCount(ctx context.Context, userDID string) (int, error) { 264 264 + recipientFilter := FilterEq("recipient_did", userDID) 265 265 + readFilter := FilterEq("read", 0) 266 266 + 267 267 + query := fmt.Sprintf(` 268 268 + SELECT COUNT(*) 269 269 + FROM notifications 270 270 + WHERE %s AND %s 271 271 + `, recipientFilter.Condition(), readFilter.Condition()) 272 272 + 273 273 + args := append(recipientFilter.Arg(), readFilter.Arg()...) 274 274 + 275 275 + var count int 276 276 + err := d.DB.QueryRowContext(ctx, query, args...).Scan(&count) 277 277 + if err != nil { 278 278 + return 0, fmt.Errorf("failed to get unread count: %w", err) 279 279 + } 280 280 + 281 281 + return count, nil 282 282 + } 283 283 + 284 284 + func (d *DB) MarkNotificationRead(ctx context.Context, notificationID int64, userDID string) error { 285 285 + idFilter := FilterEq("id", notificationID) 286 286 + recipientFilter := FilterEq("recipient_did", userDID) 287 287 + 288 288 + query := fmt.Sprintf(` 289 289 + UPDATE notifications 290 290 + SET read = 1 291 291 + WHERE %s AND %s 292 292 + `, idFilter.Condition(), recipientFilter.Condition()) 293 293 + 294 294 + args := append(idFilter.Arg(), recipientFilter.Arg()...) 295 295 + 296 296 + result, err := d.DB.ExecContext(ctx, query, args...) 297 297 + if err != nil { 298 298 + return fmt.Errorf("failed to mark notification as read: %w", err) 299 299 + } 300 300 + 301 301 + rowsAffected, err := result.RowsAffected() 302 302 + if err != nil { 303 303 + return fmt.Errorf("failed to get rows affected: %w", err) 304 304 + } 305 305 + 306 306 + if rowsAffected == 0 { 307 307 + return fmt.Errorf("notification not found or access denied") 308 308 + } 309 309 + 310 310 + return nil 311 311 + } 312 312 + 313 313 + func (d *DB) MarkAllNotificationsRead(ctx context.Context, userDID string) error { 314 314 + recipientFilter := FilterEq("recipient_did", userDID) 315 315 + readFilter := FilterEq("read", 0) 316 316 + 317 317 + query := fmt.Sprintf(` 318 318 + UPDATE notifications 319 319 + SET read = 1 320 320 + WHERE %s AND %s 321 321 + `, recipientFilter.Condition(), readFilter.Condition()) 322 322 + 323 323 + args := append(recipientFilter.Arg(), readFilter.Arg()...) 324 324 + 325 325 + _, err := d.DB.ExecContext(ctx, query, args...) 326 326 + if err != nil { 327 327 + return fmt.Errorf("failed to mark all notifications as read: %w", err) 328 328 + } 329 329 + 330 330 + return nil 331 331 + } 332 332 + 333 333 + func (d *DB) DeleteNotification(ctx context.Context, notificationID int64, userDID string) error { 334 334 + idFilter := FilterEq("id", notificationID) 335 335 + recipientFilter := FilterEq("recipient_did", userDID) 336 336 + 337 337 + query := fmt.Sprintf(` 338 338 + DELETE FROM notifications 339 339 + WHERE %s AND %s 340 340 + `, idFilter.Condition(), recipientFilter.Condition()) 341 341 + 342 342 + args := append(idFilter.Arg(), recipientFilter.Arg()...) 343 343 + 344 344 + result, err := d.DB.ExecContext(ctx, query, args...) 345 345 + if err != nil { 346 346 + return fmt.Errorf("failed to delete notification: %w", err) 347 347 + } 348 348 + 349 349 + rowsAffected, err := result.RowsAffected() 350 350 + if err != nil { 351 351 + return fmt.Errorf("failed to get rows affected: %w", err) 352 352 + } 353 353 + 354 354 + if rowsAffected == 0 { 355 355 + return fmt.Errorf("notification not found or access denied") 356 356 + } 357 357 + 358 358 + return nil 359 359 + } 360 360 + 361 361 + func (d *DB) GetNotificationPreferences(ctx context.Context, userDID string) (*models.NotificationPreferences, error) { 362 362 + userFilter := FilterEq("user_did", userDID) 363 363 + 364 364 + query := fmt.Sprintf(` 365 365 + SELECT id, user_did, repo_starred, issue_created, issue_commented, pull_created, 366 366 + pull_commented, followed, pull_merged, issue_closed, email_notifications 367 367 + FROM notification_preferences 368 368 + WHERE %s 369 369 + `, userFilter.Condition()) 370 370 + 371 371 + var prefs models.NotificationPreferences 372 372 + err := d.DB.QueryRowContext(ctx, query, userFilter.Arg()...).Scan( 373 373 + &prefs.ID, 374 374 + &prefs.UserDid, 375 375 + &prefs.RepoStarred, 376 376 + &prefs.IssueCreated, 377 377 + &prefs.IssueCommented, 378 378 + &prefs.PullCreated, 379 379 + &prefs.PullCommented, 380 380 + &prefs.Followed, 381 381 + &prefs.PullMerged, 382 382 + &prefs.IssueClosed, 383 383 + &prefs.EmailNotifications, 384 384 + ) 385 385 + 386 386 + if err != nil { 387 387 + if err == sql.ErrNoRows { 388 388 + return &models.NotificationPreferences{ 389 389 + UserDid: userDID, 390 390 + RepoStarred: true, 391 391 + IssueCreated: true, 392 392 + IssueCommented: true, 393 393 + PullCreated: true, 394 394 + PullCommented: true, 395 395 + Followed: true, 396 396 + PullMerged: true, 397 397 + IssueClosed: true, 398 398 + EmailNotifications: false, 399 399 + }, nil 400 400 + } 401 401 + return nil, fmt.Errorf("failed to get notification preferences: %w", err) 402 402 + } 403 403 + 404 404 + return &prefs, nil 405 405 + } 406 406 + 407 407 + func (d *DB) UpdateNotificationPreferences(ctx context.Context, prefs *models.NotificationPreferences) error { 408 408 + query := ` 409 409 + INSERT OR REPLACE INTO notification_preferences 410 410 + (user_did, repo_starred, issue_created, issue_commented, pull_created, 411 411 + pull_commented, followed, pull_merged, issue_closed, email_notifications) 412 412 + VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?) 413 413 + ` 414 414 + 415 415 + result, err := d.DB.ExecContext(ctx, query, 416 416 + prefs.UserDid, 417 417 + prefs.RepoStarred, 418 418 + prefs.IssueCreated, 419 419 + prefs.IssueCommented, 420 420 + prefs.PullCreated, 421 421 + prefs.PullCommented, 422 422 + prefs.Followed, 423 423 + prefs.PullMerged, 424 424 + prefs.IssueClosed, 425 425 + prefs.EmailNotifications, 426 426 + ) 427 427 + if err != nil { 428 428 + return fmt.Errorf("failed to update notification preferences: %w", err) 429 429 + } 430 430 + 431 431 + if prefs.ID == 0 { 432 432 + id, err := result.LastInsertId() 433 433 + if err != nil { 434 434 + return fmt.Errorf("failed to get preferences ID: %w", err) 435 435 + } 436 436 + prefs.ID = id 437 437 + } 438 438 + 439 439 + return nil 440 440 + } 441 441 + 442 442 + func (d *DB) ClearOldNotifications(ctx context.Context, olderThan time.Duration) error { 443 443 + cutoff := time.Now().Add(-olderThan) 444 444 + createdFilter := FilterLte("created", cutoff) 445 445 + 446 446 + query := fmt.Sprintf(` 447 447 + DELETE FROM notifications 448 448 + WHERE %s 449 449 + `, createdFilter.Condition()) 450 450 + 451 451 + _, err := d.DB.ExecContext(ctx, query, createdFilter.Arg()...) 452 452 + if err != nil { 453 453 + return fmt.Errorf("failed to cleanup old notifications: %w", err) 454 454 + } 455 455 + 456 456 + return nil 457 457 + }

+54

appview/models/notifications.go

··· 1 1 + package models 2 2 + 3 3 + import "time" 4 4 + 5 5 + type NotificationType string 6 6 + 7 7 + const ( 8 8 + NotificationTypeRepoStarred NotificationType = "repo_starred" 9 9 + NotificationTypeIssueCreated NotificationType = "issue_created" 10 10 + NotificationTypeIssueCommented NotificationType = "issue_commented" 11 11 + NotificationTypePullCreated NotificationType = "pull_created" 12 12 + NotificationTypePullCommented NotificationType = "pull_commented" 13 13 + NotificationTypeFollowed NotificationType = "followed" 14 14 + NotificationTypePullMerged NotificationType = "pull_merged" 15 15 + NotificationTypeIssueClosed NotificationType = "issue_closed" 16 16 + NotificationTypePullClosed NotificationType = "pull_closed" 17 17 + ) 18 18 + 19 19 + type Notification struct { 20 20 + ID int64 21 21 + RecipientDid string 22 22 + ActorDid string 23 23 + Type NotificationType 24 24 + EntityType string 25 25 + EntityId string 26 26 + Read bool 27 27 + Created time.Time 28 28 + 29 29 + // foreign key references 30 30 + RepoId *int64 31 31 + IssueId *int64 32 32 + PullId *int64 33 33 + } 34 34 + 35 35 + type NotificationWithEntity struct { 36 36 + *Notification 37 37 + Repo *Repo 38 38 + Issue *Issue 39 39 + Pull *Pull 40 40 + } 41 41 + 42 42 + type NotificationPreferences struct { 43 43 + ID int64 44 44 + UserDid string 45 45 + RepoStarred bool 46 46 + IssueCreated bool 47 47 + IssueCommented bool 48 48 + PullCreated bool 49 49 + PullCommented bool 50 50 + Followed bool 51 51 + PullMerged bool 52 52 + IssueClosed bool 53 53 + EmailNotifications bool 54 54 + }

+1

appview/models/repo.go

··· 10 10 ) 11 11 12 12 type Repo struct { 13 13 + Id int64 13 14 Did string 14 15 Name string 15 16 Knot string