Modern Docker Management, Designed for Everyone
Go composecontainer-managementcontainersdockerdocker-composedocker-managementgoself-hostedsveltekittypescriptweb-ui
perf(project): enrich filtered project lists after pagination (#4108)
Kyle Mendell92349aa97949
diff --git a/backend/internal/project/project.go b/backend/internal/project/project.goindex fffad092a..b3a8b5358 100644--- a/backend/internal/project/project.go+++ b/backend/internal/project/project.go@@ -206,9 +206,10 @@ type projectMetadataEnvInternal struct {autoInjectEnv bool// settings is the snapshot shared by compose loads; nil resolves lazily.settings *settings.Settings- // gitOpsComposePaths maps the listed projects' GitOps sync IDs to their- // configured compose paths. nil means the paths were not preloaded and are- // queried per project; a missing key in a preloaded map means no sync row.+ // gitOpsComposePaths maps preloaded GitOps sync IDs to their configured+ // compose paths. Sync IDs that were preloaded but have no row map to "",+ // which resolves the same way as a missing row; sync IDs absent from the+ // map are queried per project.gitOpsComposePaths map[string]string// composeFiles memoizes successfully resolved compose files by project ID.@@ -231,7 +232,14 @@ func (s *ProjectService) newProjectMetadataEnvInternal(ctx context.Context, projsettings: s.settingsService.GetSettingsOrDefaults(ctx),composeFiles: make(map[string]string, len(projectsList)),}+ s.preloadGitOpsComposePathsInternal(ctx, env, projectsList)+ return env+}+// preloadGitOpsComposePathsInternal fetches the GitOps compose paths of the+// given projects in one query and merges them into env, so list paths can+// widen the preloaded set to the rows they end up enriching.+func (s *ProjectService) preloadGitOpsComposePathsInternal(ctx context.Context, env *projectMetadataEnvInternal, projectsList []Project) {syncIDs := make([]string, 0, len(projectsList))for _, proj := range projectsList {if id := gitOpsSyncIDInternal(&proj); id != "" {@@ -239,20 +247,24 @@ func (s *ProjectService) newProjectMetadataEnvInternal(ctx context.Context, proj}}if len(syncIDs) == 0 {- return env+ return}var syncRecords []GitOpsSyncif err := s.db.WithContext(ctx).Select("id", "compose_path").Where("id IN ?", syncIDs).Find(&syncRecords).Error; err != nil {- // Leave the map nil so each project falls back to its own lookup and- // surfaces the failure the same way it did before batching.+ // Leave these IDs unloaded so each project falls back to its own lookup+ // and surfaces the failure the same way it did before batching.slog.WarnContext(ctx, "failed to batch resolve GitOps compose paths", "error", err)- return env+ return+ }+ if env.gitOpsComposePaths == nil {+ env.gitOpsComposePaths = make(map[string]string, len(syncIDs))+ }+ for _, id := range syncIDs {+ env.gitOpsComposePaths[id] = ""}- env.gitOpsComposePaths = make(map[string]string, len(syncRecords))for _, record := range syncRecords {env.gitOpsComposePaths[record.ID] = record.ComposePath}- return env}func gitOpsSyncIDInternal(proj *Project) string {@@ -714,9 +726,10 @@ func (s *ProjectService) resolveProjectComposeFileUncachedInternal(ctx context.C// gitOpsComposePathInternal returns the configured compose path of a GitOps// sync, served from the preloaded request map when one is available.func (s *ProjectService) gitOpsComposePathInternal(ctx context.Context, syncID string, env *projectMetadataEnvInternal) (string, bool, error) {- if env != nil && env.gitOpsComposePaths != nil {- composePath, found := env.gitOpsComposePaths[syncID]- return composePath, found, nil+ if env != nil {+ if composePath, preloaded := env.gitOpsComposePaths[syncID]; preloaded {+ return composePath, true, nil+ }}var syncRecord GitOpsSyncerr := s.db.WithContext(ctx).Select("compose_path").Where("id = ?", syncID).First(&syncRecord).Errordiff --git a/backend/internal/project/project_listing.go b/backend/internal/project/project_listing.goindex d32e62897..49b0b1456 100644--- a/backend/internal/project/project_listing.go+++ b/backend/internal/project/project_listing.go@@ -9,6 +9,7 @@ import ("maps""os""path/filepath"+ "slices""strings""time"@@ -107,11 +108,7 @@ func projectServiceInfoFromContainerInternal(ctx context.Context, c container.Suhealth = new("starting")}- resolvedIcon := iconcatalog.Resolve(IconCatalogForContext(ctx), iconcatalog.FirstNonEmpty(- projects.FindArcaneIconSet(c.Labels),- meta.ServiceIconSets[svcName],- meta.ProjectIcon,- ))+ resolvedIcon := resolveServiceIconInternal(IconCatalogForContext(ctx), c.Labels, svcName, meta)return ProjectServiceInfo{Name: svcName,Image: c.Image,@@ -127,6 +124,16 @@ func projectServiceInfoFromContainerInternal(ctx context.Context, c container.Su}}+// resolveServiceIconInternal picks a service icon from its container labels,+// then the compose metadata's per-service and project-level icon sets.+func resolveServiceIconInternal(catalog string, containerLabels map[string]string, serviceName string, meta projects.ArcaneComposeMetadata) iconcatalog.ResolvedIconSet {+ return iconcatalog.Resolve(catalog, iconcatalog.FirstNonEmpty(+ projects.FindArcaneIconSet(containerLabels),+ meta.ServiceIconSets[serviceName],+ meta.ProjectIcon,+ ))+}+// projectServicesFromContainersInternal derives runtime services from labeled// containers for projects whose Compose file cannot be loaded.func (s *ProjectService) projectServicesFromContainersInternal(ctx context.Context, proj *Project, meta projects.ArcaneComposeMetadata) ([]ProjectServiceInfo, error) {@@ -379,15 +386,50 @@ func (s *ProjectService) filterProjectsWithDerivedFiltersInternal(return pagination.FilterResult[project.Details]{}, errors.WrapIf(err, "failed to list projects")}- env := s.newProjectMetadataEnvInternal(ctx, projectsArray)- items := s.fetchProjectStatusConcurrently(ctx, projectsArray, env)+ // Filtering, searching, and sorting only read database columns, tags, and+ // the container snapshot, so every candidate gets a lean row and the+ // compose-backed presentation fields are resolved for the page alone.+ env := s.newProjectMetadataEnvInternal(ctx, nil)+ snapshot := s.projectContainerSnapshotInternal(ctx)+ items := s.projectListRowsInternal(ctx, env.projectsDirectory, projectsArray, snapshot)if err := s.enrichProjectsWithTagsInternal(ctx, items); err != nil {return pagination.FilterResult[project.Details]{}, err}- s.enrichProjectsWithUpdateInfoInternal(ctx, projectsArray, items, true, env)- items = s.appendDiscoveredComposeProjectUpdatesInternal(ctx, params, projectsArray, items)+ updatesFiltered := strings.TrimSpace(params.Filters["updates"]) != ""+ if updatesFiltered {+ s.preloadGitOpsComposePathsInternal(ctx, env, projectsArray)+ s.enrichProjectsWithUpdateInfoInternal(ctx, projectsArray, items, true, env)+ items = s.appendDiscoveredComposeProjectUpdatesInternal(ctx, params, projectsArray, items, snapshot)+ }- return s.buildProjectDerivedPaginationConfigInternal().SearchOrderAndPaginate(items, withoutProjectDBFiltersInternal(params)), nil+ result := s.buildProjectDerivedPaginationConfigInternal().SearchOrderAndPaginate(items, withoutProjectDBFiltersInternal(params))++ byID := make(map[string]Project, len(projectsArray))+ for _, proj := range projectsArray {+ byID[proj.ID] = proj+ }+ pageProjects := make([]Project, 0, len(result.Items))+ pageDetails := make([]project.Details, 0, len(result.Items))+ pageIndexes := make([]int, 0, len(result.Items))+ for i, item := range result.Items {+ proj, tracked := byID[item.ID]+ if !tracked {+ // Discovered compose rows are built complete.+ continue+ }+ pageProjects = append(pageProjects, proj)+ pageDetails = append(pageDetails, item)+ pageIndexes = append(pageIndexes, i)+ }+ if !updatesFiltered {+ s.preloadGitOpsComposePathsInternal(ctx, env, pageProjects)+ s.enrichProjectsWithUpdateInfoInternal(ctx, pageProjects, pageDetails, true, env)+ }+ s.applyProjectPresentationInternal(ctx, pageProjects, pageDetails, env)+ for k, i := range pageIndexes {+ result.Items[i] = pageDetails[k]+ }+ return result, nil}func withoutProjectDBFiltersInternal(params pagination.QueryParams) pagination.QueryParams {@@ -404,19 +446,18 @@ func (s *ProjectService) appendDiscoveredComposeProjectUpdatesInternal(params pagination.QueryParams,projectsArray []Project,items []project.Details,+ snapshot projectContainerSnapshotInternal,) []project.Details {if !shouldIncludeDiscoveredComposeProjectUpdatesInternal(params) {return items}-- composeContainers, err := s.listGlobalComposeContainersInternal(ctx)- if err != nil {- slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", err)+ if snapshot.err != nil {+ slog.WarnContext(ctx, "failed to list compose containers for project update rows", "error", snapshot.err)return items}knownProjectNames := s.buildKnownComposeProjectNameSetInternal(ctx, projectsArray, false)- discovered := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, composeContainers, knownProjectNames, s.imageService, IconCatalogForContext(ctx))+ discovered := buildDiscoveredComposeProjectUpdateRowsInternal(ctx, snapshot.containers, knownProjectNames, s.imageService, IconCatalogForContext(ctx))if len(discovered) == 0 {return items}@@ -911,48 +952,39 @@ func (s *ProjectService) countDiscoveredComposeProjectUpdatesInternal(ctx contexreturn len(buildDiscoveredComposeProjectUpdateRowsInternal(ctx, composeContainers, knownProjectNames, s.imageService, IconCatalogForContext(ctx)))}-// fetchProjectStatusConcurrently fetches live Docker status for multiple projects in parallel-// Optimized to use a single Docker API call instead of N calls + N file reads.-// metaEnv is resolved once for the whole list: ProjectMetadata would otherwise-// re-stat the projects directory, re-clone settings, and re-query GitOps-// compose paths per project.-func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, projectsList []Project, metaEnv *projectMetadataEnvInternal) []project.Details {- projectsDir := metaEnv.projectsDirectory+// projectContainerSnapshotInternal is the compose container listing shared by+// every row of one list request, grouped once by compose project name.+type projectContainerSnapshotInternal struct {+ containers []container.Summary+ byProject map[string][]container.Summary+ err error+ currentContainerID string+ currentContainerErr error+}- // 1. Fetch all compose containers in one go+func (s *ProjectService) projectContainerSnapshotInternal(ctx context.Context) projectContainerSnapshotInternal {containers, err := s.listGlobalComposeContainersInternal(ctx)if err != nil {slog.ErrorContext(ctx, "Failed to list global compose containers", "error", err)- // Fallback: return basic info with unknown status- metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)- results := make([]project.Details, len(projectsList))- for i, p := range projectsList {- _ = mapper.MapStruct(p, &results[i])- results[i].CreatedAt = p.CreatedAt.Format(time.RFC3339)- results[i].UpdatedAt = p.UpdatedAt.Format(time.RFC3339)- results[i].DirName = mo.PointerToOption(p.DirName).OrEmpty()- results[i].RelativePath = getProjectRelativePathInternal(projectsDir, p.Path)- results[i].GitOpsManagedBy = p.GitOpsManagedBy- results[i].HasBuildDirective = p.BuildImageRefsJSON != nil && len(projects.ParseImageRefsJSON(*p.BuildImageRefsJSON)) > 0- applyResolvedProjectIconInternal(&results[i], iconcatalog.Resolve(IconCatalogForContext(ctx), metas[i].ProjectIcon))- results[i].URLs = metas[i].ProjectURLS- results[i].ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, p.Path)- results[i].Status = string(ProjectStatusUnknown)- }- return results+ return projectContainerSnapshotInternal{err: err}}-- // 2. Group containers by project name- containersByProject := groupComposeContainersByProjectInternal(containers)-- // 3. Map to DTOs- metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)- results := make([]project.Details, len(projectsList))currentContainerID, currentContainerErr := cgroup.CurrentContainerID()- for i, p := range projectsList {- results[i] = s.mapProjectToDto(ctx, projectsDir, p, containersByProject, currentContainerID, currentContainerErr, metas[i])+ return projectContainerSnapshotInternal{+ containers: containers,+ byProject: groupComposeContainersByProjectInternal(containers),+ currentContainerID: currentContainerID,+ currentContainerErr: currentContainerErr,}+}+// fetchProjectStatusConcurrently builds complete list rows for an already+// paginated page: live status from a single Docker API call plus the+// compose-backed presentation fields. metaEnv is resolved once for the whole+// list: ProjectMetadata would otherwise re-stat the projects directory,+// re-clone settings, and re-query GitOps compose paths per project.+func (s *ProjectService) fetchProjectStatusConcurrently(ctx context.Context, projectsList []Project, metaEnv *projectMetadataEnvInternal) []project.Details {+ results := s.projectListRowsInternal(ctx, metaEnv.projectsDirectory, projectsList, s.projectContainerSnapshotInternal(ctx))+ s.applyProjectPresentationInternal(ctx, projectsList, results, metaEnv)return results}@@ -973,7 +1005,87 @@ func (s *ProjectService) resolveProjectMetadataConcurrentlyInternal(ctx context.return metas}-func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir string, p Project, containersByProject map[string][]container.Summary, currentContainerID string, currentContainerErr error, meta projects.ArcaneComposeMetadata) project.Details {+// applyProjectPresentationInternal resolves compose metadata for projectsList+// and fills the fields filtering and sorting never read: project and service+// icons, custom URLs, and the env access probe. details must align with+// projectsList by index.+func (s *ProjectService) applyProjectPresentationInternal(ctx context.Context, projectsList []Project, details []project.Details, metaEnv *projectMetadataEnvInternal) {+ if len(projectsList) == 0 {+ return+ }+ metas := s.resolveProjectMetadataConcurrentlyInternal(ctx, projectsList, metaEnv)+ catalog := IconCatalogForContext(ctx)+ for i := range projectsList {+ resp := &details[i]+ applyResolvedProjectIconInternal(resp, iconcatalog.Resolve(catalog, metas[i].ProjectIcon))+ resp.URLs = metas[i].ProjectURLS+ resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, metaEnv.projectsDirectory, projectsList[i].Path)+ for k := range resp.RuntimeServices {+ service := &resp.RuntimeServices[k]+ icon := resolveServiceIconInternal(catalog, service.ContainerLabels, service.Name, metas[i])+ service.IconLightURL, service.IconDarkURL = icon.IconLightURL, icon.IconDarkURL+ }+ }+}++func (s *ProjectService) projectListRowsInternal(ctx context.Context, projectsDir string, projectsList []Project, snapshot projectContainerSnapshotInternal) []project.Details {+ rows := make([]project.Details, len(projectsList))+ inferredCounts := make(map[string]int)+ for i, p := range projectsList {+ rows[i] = projectListRowInternal(ctx, projectsDir, p, snapshot)+ if p.ServiceCount == 0 && rows[i].ServiceCount > 0 {+ inferredCounts[p.ID] = rows[i].ServiceCount+ }+ }+ s.persistInferredServiceCountsInternal(ctx, inferredCounts)+ return rows+}++// persistInferredServiceCountsInternal writes service counts inferred from live+// containers back to projects whose stored count is still zero. The plain list+// path sorts and paginates on the service_count column in SQL before rows are+// enriched, so a count that only lives in the response leaves those projects+// on the wrong page until a filesystem sync parses their compose file. The+// write runs synchronously on the request context as one batched statement+// per chunk: it only fires for projects that still have a zero count, so it is+// cheap and needs no detached goroutine. Failures are logged; the response+// already carries the inferred value.+func (s *ProjectService) persistInferredServiceCountsInternal(ctx context.Context, counts map[string]int) {+ if len(counts) == 0 || s.db == nil {+ return+ }+ ids := make([]string, 0, len(counts))+ for id := range counts {+ ids = append(ids, id)+ }+ for chunk := range slices.Chunk(ids, inferredServiceCountBatchSizeInternal) {+ var caseExpr strings.Builder+ args := make([]any, 0, 2*len(chunk))+ caseExpr.WriteString("CASE id")+ for _, id := range chunk {+ caseExpr.WriteString(" WHEN ? THEN ?")+ args = append(args, id, counts[id])+ }+ caseExpr.WriteString(" ELSE service_count END")+ if err := s.db.WithContext(ctx).Model(&Project{}).+ Where("id IN ? AND service_count = 0", chunk).+ Update("service_count", gorm.Expr(caseExpr.String(), args...)).Error; err != nil {+ slog.WarnContext(ctx, "failed to persist inferred project service counts", "count", len(chunk), "error", err)+ return+ }+ }+}++// inferredServiceCountBatchSizeInternal bounds the ids in one inferred+// service count update so the statement stays under SQLite's bound variable+// limit (two placeholders per id in the CASE plus one in the IN list).+const inferredServiceCountBatchSizeInternal = 200++// projectListRowInternal builds the fields the list filters, search, and sort+// read from database columns and the shared container snapshot. Fields that+// need compose metadata are left for applyProjectPresentationInternal. When+// the container listing failed the row reports an unknown status.+func projectListRowInternal(ctx context.Context, projectsDir string, p Project, snapshot projectContainerSnapshotInternal) project.Details {var resp project.Details_ = mapper.MapStruct(p, &resp)@@ -985,60 +1097,33 @@ func (s *ProjectService) mapProjectToDto(ctx context.Context, projectsDir stringresp.RelativePath = getProjectRelativePathInternal(projectsDir, p.Path)resp.GitOpsManagedBy = p.GitOpsManagedByresp.HasBuildDirective = p.BuildImageRefsJSON != nil && len(projects.ParseImageRefsJSON(*p.BuildImageRefsJSON)) > 0- applyResolvedProjectIconInternal(&resp, iconcatalog.Resolve(IconCatalogForContext(ctx), meta.ProjectIcon))- resp.URLs = meta.ProjectURLS- resp.ConfigurationError = projects.CheckProjectEnvAccess(ctx, projectsDir, p.Path)-- projectContainers := lookupProjectContainersInternal(p, containersByProject)+ // Use DB service count as the source of truth for "Total Services"+ // since we are not parsing the YAML here.+ resp.ServiceCount = p.ServiceCount+ if snapshot.err != nil {+ resp.Status = string(ProjectStatusUnknown)+ return resp+ }+ projectContainers := lookupProjectContainersInternal(p, snapshot.byProject)services := make([]ProjectServiceInfo, 0, len(projectContainers))-for _, c := range projectContainers {- service := projectServiceInfoFromContainerInternal(ctx, c, meta, currentContainerID, currentContainerErr)+ service := projectServiceInfoFromContainerInternal(ctx, c, projects.ArcaneComposeMetadata{}, snapshot.currentContainerID, snapshot.currentContainerErr)if service.RedeployDisabled {resp.RedeployDisabled = true}services = append(services, service)}_, runningCount := getServiceCounts(services)-- // Convert to RuntimeServices- runtimeServices := make([]project.RuntimeService, len(services))- for k, s := range services {- runtimeServices[k] = project.RuntimeService{- Name: s.Name,- Image: s.Image,- Status: s.Status,- ContainerID: s.ContainerID,- ContainerLabels: s.Labels,- ContainerName: s.ContainerName,- Ports: s.Ports,- Health: s.Health,- IconLightURL: s.IconLightURL,- IconDarkURL: s.IconDarkURL,- ServiceConfig: s.ServiceConfig,- RedeployDisabled: s.RedeployDisabled,- }- }- resp.RuntimeServices = runtimeServices-- // Use DB service count as the source of truth for "Total Services"- // since we are not parsing the YAML here.- resp.ServiceCount = p.ServiceCount+ resp.RuntimeServices = buildProjectRuntimeServicesInternal(services)resp.RunningCount = runningCount+ // Newly discovered projects have no persisted count yet. Infer it from the+ // live containers; projectListRowsInternal persists the inferred value so+ // SQL sorting and pagination on service_count see it on later requests.if resp.ServiceCount == 0 && len(services) > 0 {resp.ServiceCount = len(services)- // Persist the inferred count so later list loads do not need compose parsing.- go func(ctx context.Context, pid string, count int) {- s.db.WithContext(ctx).Model(&Project{}).Where("id = ?", pid).Update("service_count", count)- }(context.WithoutCancel(ctx), p.ID, resp.ServiceCount)}- // For missing service count (e.g. newly discovered projects), skip the- // expensive CountServicesFromCompose call which loads and parses the entire- // compose project. The count will be populated the next time the project- // detail endpoint is called or during the periodic filesystem sync.-// Calculate Status using actual container count from Docker rather than the// (potentially stale) DB ServiceCount. The DB value can become outdated when// a service is removed from the compose file but compose parsing fails duringdiff --git a/backend/internal/project/service_test.go b/backend/internal/project/service_test.goindex f17b691b2..bcfac013c 100644--- a/backend/internal/project/service_test.go+++ b/backend/internal/project/service_test.go@@ -4226,9 +4226,8 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {- service := &ProjectService{}tt.labels[composeapi.WorkingDirLabel] = projectPath- details := service.mapProjectToDto(context.Background(), filepath.Dir(projectPath), proj, map[string][]container.Summary{+ details := projectListRowInternal(context.Background(), filepath.Dir(projectPath), proj, projectContainerSnapshotInternal{byProject: map[string][]container.Summary{"arcane": {{ID: tt.containerID,@@ -4247,7 +4246,7 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(},},},- }, tt.currentContainerID, tt.currentErr, projects.ArcaneComposeMetadata{})+ }, currentContainerID: tt.currentContainerID, currentContainerErr: tt.currentErr})require.Equal(t, tt.wantProject, details.RedeployDisabled)require.Len(t, details.RuntimeServices, 1)@@ -4257,6 +4256,49 @@ func TestProjectService_MapProjectToDto_SetsRedeployDisabledFromRuntimeServices(}}+func TestProjectService_ProjectListRows_PersistsInferredServiceCount(t *testing.T) {+ db := setupProjectTestDB(t)+ projectsDir := t.TempDir()+ projectPath := filepath.Join(projectsDir, "inferred")+ require.NoError(t, os.MkdirAll(projectPath, 0o755))+ inferred := Project{ID: "inferred", Name: "inferred", Path: projectPath, ServiceCount: 0}+ known := Project{ID: "known", Name: "known", Path: filepath.Join(projectsDir, "known"), ServiceCount: 4}+ require.NoError(t, db.Create(&inferred).Error)+ require.NoError(t, db.Create(&known).Error)+ service := &ProjectService{db: db}++ snapshot := projectContainerSnapshotInternal{byProject: map[string][]container.Summary{+ "inferred": {+ {ID: "c1", State: "running", Names: []string{"/inferred-web"}, Labels: map[string]string{+ composeapi.ProjectLabel: "inferred", composeapi.ServiceLabel: "web", composeapi.WorkingDirLabel: projectPath,+ }},+ {ID: "c2", State: "exited", Names: []string{"/inferred-db"}, Labels: map[string]string{+ composeapi.ProjectLabel: "inferred", composeapi.ServiceLabel: "db", composeapi.WorkingDirLabel: projectPath,+ }},+ },+ "known": {+ {ID: "c3", State: "running", Names: []string{"/known-web"}, Labels: map[string]string{+ composeapi.ProjectLabel: "known", composeapi.ServiceLabel: "web", composeapi.WorkingDirLabel: known.Path,+ }},+ },+ }}++ rows := service.projectListRowsInternal(context.Background(), projectsDir, []Project{inferred, known}, snapshot)+ require.Len(t, rows, 2)+ require.Equal(t, 2, rows[0].ServiceCount)+ require.Equal(t, 4, rows[1].ServiceCount)++ // The inferred count is persisted because the plain list path sorts and+ // paginates on this column in SQL.+ var stored Project+ require.NoError(t, db.First(&stored, "id = ?", "inferred").Error)+ require.Equal(t, 2, stored.ServiceCount)++ var storedKnown Project+ require.NoError(t, db.First(&storedKnown, "id = ?", "known").Error)+ require.Equal(t, 4, storedKnown.ServiceCount, "a persisted non-zero count must not be overwritten by the live container count")+}+func TestProjectService_ListProjects_WithDerivedStatusFilter_AllowsAllPageSizeSentinel(t *testing.T) {db := setupProjectTestDB(t)ctx := context.Background()@@ -7188,14 +7230,9 @@ func TestProjectService_RecoverProjectRenameJournals_ClearsJournalWhenTargetPresrequire.NoDirExists(t, newPath)}-func TestProjectService_MapProjectToDto_SeedsHasBuildDirectiveFromPersistedRefs(t *testing.T) {+func TestProjectListRow_SeedsHasBuildDirectiveFromPersistedRefs(t *testing.T) {ctx := context.Background()- db := setupProjectTestDB(t)- settingsService, err := newSettingsServiceForTestInternal(t, ctx, db)- require.NoError(t, err)-- svc := NewProjectService(db, settingsService, nil, nil, nil, nil, nil, nil, config.Load())- metaEnv := &projectMetadataEnvInternal{projectsDirectory: t.TempDir()}+ projectsDirectory := t.TempDir()now := time.Now()tests := []struct {@@ -7211,7 +7248,7 @@ func TestProjectService_MapProjectToDto_SeedsHasBuildDirectiveFromPersistedRefs(for _, tt := range tests {t.Run(tt.name, func(t *testing.T) {p := Project{ID: tt.name, Name: tt.name, Path: t.TempDir(), UpdatedAt: &now, BuildImageRefsJSON: tt.buildImageRefsJSON}- assert.Equal(t, tt.want, svc.mapProjectToDto(ctx, metaEnv.projectsDirectory, p, nil, "", nil, svc.ProjectMetadata(ctx, p, metaEnv)).HasBuildDirective)+ assert.Equal(t, tt.want, projectListRowInternal(ctx, projectsDirectory, p, projectContainerSnapshotInternal{}).HasBuildDirective)})}}