## [0.3.20] - 2026-01-14

- GitLab sync: incremental refresh now includes state transitions (open/closed) by fetching updated issues with `state=all`; always updates issues already in cache/graph regardless of `gitlabClosedDays` (which only affects adding new closed issues).

Author: tdev

CHANGELOG.md

@@ -1,5 +1,8 @@
 # Changelog
 
+## [0.3.20] - 2026-01-14
+- GitLab sync: incremental refresh now includes state transitions (open/closed) by fetching updated issues with `state=all`; always updates issues already in cache/graph regardless of `gitlabClosedDays` (which only affects adding new closed issues).
+
 ## [0.3.19] - 2026-01-09
 - Graph perf: speed up physics overlap resolution on large graphs; faster zoomed-out drawing (LOD) + cached group smudges; faster group label toggling.
 - improved frame fit

package.json

@@ -13,7 +13,7 @@
   ],
   "author": "Thomas Fischer <tfischer@beamng.gmbh>",
   "private": true,
-  "version": "0.3.19",
+  "version": "0.3.20",
   "license": "MIT",
   "engines": {
     "node": ">=20"

src/composables/useDataLoader.js

@@ -279,54 +279,88 @@ export function useDataLoader ({
             settings.meta.gitlabCanWrite = false
           }
 
-          // Fetch opened issues (REST: fast + includes epic_iid)
-          issues = await fetchProjectIssuesRest(
-            restClient,
-            settings.config.projectId,
-            (msg) => {
-              loadingMessage.value = msg
-              updateStatus.value = { loading: true, source: 'gitlab', message: msg }
-            },
-            updatedAfter ? { params: { updated_after: updatedAfter } } : {}
-          )
-          const partialOpened = !!issues?.__glvPartial
-
-          // Fetch closed issues if requested
-          if (settings.config.gitlabClosedDays > 0) {
-            const closedAfter = new Date()
-            closedAfter.setDate(closedAfter.getDate() - settings.config.gitlabClosedDays)
-
-            const closedAfterMs = closedAfter.getTime()
-            const closedUpdatedAfter = (() => {
-              if (!updatedAfter) return closedAfter.toISOString()
-              const updatedAfterMs = parseCursorMs(updatedAfter)
-              if (updatedAfterMs == null) return closedAfter.toISOString()
-              return new Date(Math.max(closedAfterMs, updatedAfterMs)).toISOString()
-            })()
-
-            const closedIssues = await fetchProjectIssuesRest(
+          if (updatedAfter) {
+            // Incremental sync must include state transitions (opened <-> closed), not just new opened issues.
+            const updated = await fetchProjectIssuesRest(
               restClient,
               settings.config.projectId,
               (msg) => {
                 loadingMessage.value = msg
                 updateStatus.value = { loading: true, source: 'gitlab', message: msg }
               },
-              {
-                state: 'closed',
-                params: {
-                  updated_after: closedUpdatedAfter
-                }
-              }
+              { state: 'all', params: { updated_after: updatedAfter } }
             )
-            const partialClosed = !!closedIssues?.__glvPartial
+            const partialUpdated = !!updated?.__glvPartial
+
+            // NOTE: In incremental mode, always apply updates for issues that are already in cache/graph,
+            // regardless of gitlabClosedDays. gitlabClosedDays only affects adding *new* closed issues.
+            const closedAfter = (() => {
+              if (!(settings.config.gitlabClosedDays > 0)) return null
+              const d = new Date()
+              d.setDate(d.getDate() - settings.config.gitlabClosedDays)
+              return d
+            })()
+            issues = updated.filter(i => {
+              if (!i || i.iid == null) return false
+              const id = String(i.iid)
+              const exists = !!nodes[id]
+              if (i.state !== 'closed') return true
+              if (exists) return true
+              if (!closedAfter) return false
+              return !!(i.closed_at && new Date(i.closed_at) >= closedAfter)
+            })
 
-            // Filter to ensure they were actually closed after the date (updated_after is broader)
-            const actuallyClosed = closedIssues.filter(i => i.closed_at && new Date(i.closed_at) >= closedAfter)
-            issues = [...issues, ...actuallyClosed]
-            // propagate partial marker
-            if (partialOpened || partialClosed) {
+            if (partialUpdated) {
               try { Object.defineProperty(issues, '__glvPartial', { value: true, enumerable: false }) } catch {}
             }
+          } else {
+            // Full fetch: opened issues (REST: fast + includes epic_iid)
+            issues = await fetchProjectIssuesRest(
+              restClient,
+              settings.config.projectId,
+              (msg) => {
+                loadingMessage.value = msg
+                updateStatus.value = { loading: true, source: 'gitlab', message: msg }
+              }
+            )
+            const partialOpened = !!issues?.__glvPartial
+
+            // Fetch closed issues if requested
+            if (settings.config.gitlabClosedDays > 0) {
+              const closedAfter = new Date()
+              closedAfter.setDate(closedAfter.getDate() - settings.config.gitlabClosedDays)
+
+              const closedAfterMs = closedAfter.getTime()
+              const closedUpdatedAfter = (() => {
+                const updatedAfterMs = parseCursorMs(updatedAfter)
+                if (updatedAfterMs == null) return closedAfter.toISOString()
+                return new Date(Math.max(closedAfterMs, updatedAfterMs)).toISOString()
+              })()
+
+              const closedIssues = await fetchProjectIssuesRest(
+                restClient,
+                settings.config.projectId,
+                (msg) => {
+                  loadingMessage.value = msg
+                  updateStatus.value = { loading: true, source: 'gitlab', message: msg }
+                },
+                {
+                  state: 'closed',
+                  params: {
+                    updated_after: closedUpdatedAfter
+                  }
+                }
+              )
+              const partialClosed = !!closedIssues?.__glvPartial
+
+              // Filter to ensure they were actually closed after the date (updated_after is broader)
+              const actuallyClosed = closedIssues.filter(i => i.closed_at && new Date(i.closed_at) >= closedAfter)
+              issues = [...issues, ...actuallyClosed]
+              // propagate partial marker
+              if (partialOpened || partialClosed) {
+                try { Object.defineProperty(issues, '__glvPartial', { value: true, enumerable: false }) } catch {}
+              }
+            }
           }
 
           // Optional GraphQL enrichment pass for fields REST doesn't provide (kept minimal).

src/composables/useDataLoader.test.js

@@ -294,6 +294,114 @@ describe('useDataLoader', () => {
     confirmSpy.mockRestore()
   })
 
+  it('loadData (gitlab incremental) syncs closed transitions (keeps and updates cached issues even when gitlabClosedDays=0)', async () => {
+    const gitlab = await import('../services/gitlab')
+
+    const closedIssue = {
+      iid: 1,
+      title: 'A',
+      state: 'closed',
+      labels: [],
+      author: { name: 'Alice' },
+      assignee: null,
+      assignees: [],
+      milestone: null,
+      created_at: new Date(Date.now() - 2 * 60 * 60 * 1000).toISOString(),
+      updated_at: new Date().toISOString(),
+      closed_at: new Date().toISOString(),
+      due_date: null,
+      web_url: '',
+      confidential: false,
+      time_stats: { time_estimate: 0, total_time_spent: 0 },
+      user_notes_count: 0,
+      merge_requests_count: 0,
+      upvotes: 0,
+      downvotes: 0,
+      has_tasks: false,
+      task_status: null
+    }
+
+    gitlab.fetchProjectIssuesRest.mockResolvedValueOnce([closedIssue])
+
+    const settings = reactive({
+      meta: {},
+      config: {
+        enableGitLab: true,
+        enableSvn: false,
+        token: 't',
+        projectId: 'p',
+        gitlabApiBaseUrl: 'https://gitlab.example.com',
+        gitlabClosedDays: 0
+      }
+    })
+    const nodes = reactive({ '1': { id: '1', type: 'gitlab_issue', _raw: { state: 'opened' } } })
+    const edges = reactive({ '1-2': { source: '1', target: '2' }, 'svn-1-1': { source: 'svn-1', target: '1' } })
+    const issueGraphSnapshot = reactive({ nodes: {}, edges: {} })
+    const svnUrl = ref('')
+    const svnVizLimit = ref(2000)
+    const svnRecentCommits = ref([])
+    const svnCommitCount = ref(0)
+    const gitlabCacheMeta = ref({
+      projectId: 'p',
+      apiBaseUrl: 'https://gitlab.example.com/api/v4',
+      syncCursor: new Date(Date.now() - 60 * 60 * 1000).toISOString()
+    })
+    const mattermostMeta = ref({})
+    const lastUpdated = ref(null)
+    const loading = ref(false)
+    const loadingMessage = ref('')
+    const updateStatus = ref({})
+    const error = ref('')
+    const isElectron = ref(false)
+    const canUseSvn = ref(false)
+    const vizMode = ref('issues')
+
+    const { loadData } = useDataLoader({
+      settings,
+      nodes,
+      edges,
+      issueGraphSnapshot,
+      svnUrl,
+      svnVizLimit,
+      svnRecentCommits,
+      svnCommitCount,
+      gitlabCacheMeta,
+      mattermostMeta,
+      lastUpdated,
+      loading,
+      loadingMessage,
+      updateStatus,
+      error,
+      isElectron,
+      canUseSvn,
+      vizMode,
+      buildSvnVizGraph: () => {},
+      resetFilters: () => {},
+      createMockIssuesGraph: () => ({ nodes: {}, edges: {} })
+    })
+
+    await loadData()
+
+    // cached issues are kept and updated (gitlabClosedDays does not block updates)
+    expect(nodes['1']).toBeTruthy()
+    expect(nodes['1']?.closedAt).toBeTruthy()
+    // issue-link edges touching updated issues are cleared for re-linking
+    expect(Object.keys(edges).some(k => k.includes('1-2'))).toBe(false)
+    // but non-issue edges (e.g. SVN) remain
+    expect(Object.keys(edges).some(k => k.includes('svn'))).toBe(true)
+
+    // incremental fetch uses state=all + updated_after
+    expect(gitlab.fetchProjectIssuesRest).toHaveBeenCalledWith(
+      expect.anything(),
+      'p',
+      expect.any(Function),
+      expect.objectContaining({
+        state: 'all',
+        params: expect.objectContaining({ updated_after: expect.any(String) })
+      })
+    )
+  })
+
   it('initCachedData uses createMockIssuesGraph when cache empty', async () => {
     await localforage.clear()