package github import ( "context" "errors" "fmt" "strings" ) var ErrWorkspaceSettingsValidation = errors.New("invalid workspace settings") // GetWorkspaceSettings returns the GitHub operational settings for a workspace. func (s *Service) GetWorkspaceSettings(ctx context.Context, workspaceID string) (*WorkspaceSettings, error) { if s.store == nil { return defaultWorkspaceSettings(workspaceID), nil } return s.store.GetWorkspaceSettings(ctx, workspaceID) } // UpsertWorkspaceSettings stores the GitHub operational settings for a workspace. func (s *Service) UpsertWorkspaceSettings(ctx context.Context, settings *WorkspaceSettings) error { if s.store == nil { return fmt.Errorf("github store not configured") } return s.store.UpsertWorkspaceSettings(ctx, settings) } // UpdateWorkspaceSettings applies a partial update over the existing workspace // settings. Scope fields are intentionally updated as a set so switching to // All repos clears org/repo selections. Direct struct callers must set // SavedPresetsSet/DefaultQueriesSet when they intend to write those blobs; // JSON-bound requests set those flags in UpdateWorkspaceSettingsRequest.UnmarshalJSON. func (s *Service) UpdateWorkspaceSettings(ctx context.Context, req *UpdateWorkspaceSettingsRequest) (*WorkspaceSettings, error) { if req == nil || strings.TrimSpace(req.WorkspaceID) == "" { return nil, fmt.Errorf("%w: workspace_id is required", ErrWorkspaceSettingsValidation) } if req.RepoScopeMode != nil && !isValidRepoScopeMode(*req.RepoScopeMode) { return nil, fmt.Errorf("%w: invalid repo_scope_mode %q", ErrWorkspaceSettingsValidation, *req.RepoScopeMode) } if s.store == nil { return nil, fmt.Errorf("github store not configured") } return s.store.PatchWorkspaceSettings(ctx, req) } func (s *Service) SearchUserPRsPagedForWorkspace( ctx context.Context, workspaceID string, filter string, customQuery string, page int, perPage int, ) (*PRSearchPage, error) { settings, err := s.GetWorkspaceSettings(ctx, workspaceID) if err != nil { return nil, err } if !workspaceSettingsHasScope(settings) { return s.SearchUserPRsPaged(ctx, filter, customQuery, page, perPage) } return s.searchUserPRsPagedScoped(ctx, settings, filter, customQuery, page, perPage) } func (s *Service) SearchUserIssuesPagedForWorkspace( ctx context.Context, workspaceID string, filter string, customQuery string, page int, perPage int, ) (*IssueSearchPage, error) { settings, err := s.GetWorkspaceSettings(ctx, workspaceID) if err != nil { return nil, err } if !workspaceSettingsHasScope(settings) { return s.SearchUserIssuesPaged(ctx, filter, customQuery, page, perPage) } return s.searchUserIssuesPagedScoped(ctx, settings, filter, customQuery, page, perPage) } func (s *Service) searchUserPRsPagedScoped( ctx context.Context, settings *WorkspaceSettings, filter string, customQuery string, page int, perPage int, ) (*PRSearchPage, error) { if workspaceSettingsHasEmptyScope(settings) { return &PRSearchPage{PRs: []*PR{}, TotalCount: 0, Page: page, PerPage: perPage}, nil } filter, customQuery = appendWorkspaceScopeToSearch(filter, customQuery, settings) v, err := s.searchUserPagedScoped("pr", settings, filter, customQuery, page, perPage, func(page, perPage int) (any, error) { result, err := s.client.SearchPRsPaged(ctx, filter, customQuery, page, perPage) if err != nil { return nil, err } return scopedPRSearchPage(result, settings, page, perPage), nil }) if err != nil { return nil, err } return v.(*PRSearchPage), nil } func (s *Service) searchUserIssuesPagedScoped( ctx context.Context, settings *WorkspaceSettings, filter string, customQuery string, page int, perPage int, ) (*IssueSearchPage, error) { if workspaceSettingsHasEmptyScope(settings) { return &IssueSearchPage{Issues: []*Issue{}, TotalCount: 0, Page: page, PerPage: perPage}, nil } filter, customQuery = appendWorkspaceScopeToSearch(filter, customQuery, settings) v, err := s.searchUserPagedScoped("issue", settings, filter, customQuery, page, perPage, func(page, perPage int) (any, error) { result, err := s.client.ListIssuesPaged(ctx, filter, customQuery, page, perPage) if err != nil { return nil, err } return scopedIssueSearchPage(result, settings, page, perPage), nil }) if err != nil { return nil, err } return v.(*IssueSearchPage), nil } func (s *Service) searchUserPagedScoped( kind string, settings *WorkspaceSettings, filter string, customQuery string, page int, perPage int, fetch func(page int, perPage int) (any, error), ) (any, error) { if s.client == nil { return nil, fmt.Errorf("github client not available") } page, perPage = clampSearchPage(page, perPage) scopeKey := workspaceSearchScopeKey(settings) key := searchCacheKey(kind+":"+scopeKey, filter, customQuery, page, perPage) return s.searchCache.doOrFetch(key, func() (any, error) { return fetch(page, perPage) }) } func scopedPRSearchPage(result *PRSearchPage, settings *WorkspaceSettings, page int, perPage int) *PRSearchPage { if result == nil { result = &PRSearchPage{Page: page, PerPage: perPage} } result.PRs = filterPRsByWorkspaceScope(result.PRs, settings) result.Page = page result.PerPage = perPage return result } func scopedIssueSearchPage(result *IssueSearchPage, settings *WorkspaceSettings, page int, perPage int) *IssueSearchPage { if result == nil { result = &IssueSearchPage{Page: page, PerPage: perPage} } result.Issues = filterIssuesByWorkspaceScope(result.Issues, settings) result.Page = page result.PerPage = perPage return result } func workspaceSettingsHasScope(settings *WorkspaceSettings) bool { settings = normalizeWorkspaceSettings(settings) if settings == nil { return false } switch settings.RepoScopeMode { case RepoScopeModeOrgs, RepoScopeModeRepos: return true default: return false } } func workspaceSettingsHasEmptyScope(settings *WorkspaceSettings) bool { return workspaceSettingsHasScope(settings) && len(workspaceScopeQualifiers(settings)) == 0 } func isValidRepoScopeMode(mode string) bool { switch strings.TrimSpace(strings.ToLower(mode)) { case RepoScopeModeAll, RepoScopeModeOrgs, RepoScopeModeRepos: return true default: return false } } func appendWorkspaceScopeQuery(customQuery string, settings *WorkspaceSettings) string { qualifiers := workspaceScopeQualifiers(settings) if len(qualifiers) == 0 { return customQuery } scope := qualifiers[0] if len(qualifiers) > 1 { scope = "(" + strings.Join(qualifiers, " OR ") + ")" } return strings.TrimSpace(strings.Join([]string{customQuery, scope}, " ")) } func appendWorkspaceScopeToSearch(filter, customQuery string, settings *WorkspaceSettings) (string, string) { if strings.TrimSpace(customQuery) != "" { return filter, appendWorkspaceScopeQuery(customQuery, settings) } return appendWorkspaceScopeQuery(filter, settings), customQuery } func workspaceScopeQualifiers(settings *WorkspaceSettings) []string { settings = normalizeWorkspaceSettings(settings) if settings == nil { return nil } switch settings.RepoScopeMode { case RepoScopeModeOrgs: qualifiers := make([]string, 0, len(settings.RepoScopeOrgs)*2) for _, org := range settings.RepoScopeOrgs { if org = strings.TrimSpace(org); org != "" { qualifiers = append(qualifiers, "org:"+org) qualifiers = append(qualifiers, "user:"+org) } } return qualifiers case RepoScopeModeRepos: qualifiers := make([]string, 0, len(settings.RepoScopeRepos)) for _, repo := range settings.RepoScopeRepos { if repo.Owner != "" && repo.Name != "" { qualifiers = append(qualifiers, repoFilterToQualifier(repo)) } } return qualifiers default: return nil } } func workspaceScopeRepoFilters(settings *WorkspaceSettings) []RepoFilter { settings = normalizeWorkspaceSettings(settings) if settings == nil { return nil } switch settings.RepoScopeMode { case RepoScopeModeOrgs: repos := make([]RepoFilter, 0, len(settings.RepoScopeOrgs)) for _, org := range settings.RepoScopeOrgs { if org = strings.TrimSpace(org); org != "" { repos = append(repos, RepoFilter{Owner: org}) } } return repos case RepoScopeModeRepos: return append([]RepoFilter(nil), settings.RepoScopeRepos...) default: return nil } } func workspaceSearchScopeKey(settings *WorkspaceSettings) string { settings = normalizeWorkspaceSettings(settings) if settings == nil { return RepoScopeModeAll } var parts []string switch settings.RepoScopeMode { case RepoScopeModeOrgs: parts = append(parts, settings.RepoScopeOrgs...) case RepoScopeModeRepos: for _, repo := range settings.RepoScopeRepos { parts = append(parts, repo.Owner+"/"+repo.Name) } } return settings.RepoScopeMode + ":" + strings.Join(parts, ",") } func filterPRsByWorkspaceScope(prs []*PR, settings *WorkspaceSettings) []*PR { if !workspaceSettingsHasScope(settings) { if prs == nil { return []*PR{} } return prs } out := make([]*PR, 0, len(prs)) for _, pr := range prs { if pr != nil && repoAllowedByWorkspaceScope(pr.RepoOwner, pr.RepoName, settings) { out = append(out, pr) } } return out } func filterIssuesByWorkspaceScope(issues []*Issue, settings *WorkspaceSettings) []*Issue { if !workspaceSettingsHasScope(settings) { if issues == nil { return []*Issue{} } return issues } out := make([]*Issue, 0, len(issues)) for _, issue := range issues { if issue != nil && repoAllowedByWorkspaceScope(issue.RepoOwner, issue.RepoName, settings) { out = append(out, issue) } } return out } func repoAllowedByWorkspaceScope(owner, name string, settings *WorkspaceSettings) bool { settings = normalizeWorkspaceSettings(settings) if settings == nil || settings.RepoScopeMode == RepoScopeModeAll { return true } owner = strings.ToLower(strings.TrimSpace(owner)) name = strings.ToLower(strings.TrimSpace(name)) switch settings.RepoScopeMode { case RepoScopeModeOrgs: for _, org := range settings.RepoScopeOrgs { if strings.ToLower(org) == owner { return true } } case RepoScopeModeRepos: for _, repo := range settings.RepoScopeRepos { if strings.ToLower(repo.Owner) == owner && strings.ToLower(repo.Name) == name { return true } } } return false }