From e3548c3bb40e1dfd6b9f3425b62e0aa1fe2656b3 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 29 Jul 2026 12:17:57 +0200
Subject: [PATCH 01/24] fix: stop stuck top loading bar on admin dataset pages

NuxtPage's page-key was bound to an inline arrow function
(`route => route.fullPath`) in two admin layouts. Vue recreates that
function on every render of the owning component, and NuxtPage
compares page-key by reference (not by the value it computes) to
decide whether to fire the page-loading indicator. A fresh reference
for the same route is treated as "the page changed", firing
page:loading:start with no matching navigation to ever complete it,
so the top loading bar gets stuck.

This went unnoticed because nothing previously triggered it: it only
fires when the owning component re-renders while mounted, e.g. when
pages/admin/datasets/[id].vue's own `dataset` (fetched via the same
useAPI call/URL/options as a nested tab's own dataset fetch, and
therefore sharing the same Nuxt useFetch cache key) gets refreshed by
that nested tab.

Fix: bind page-key to a stable, hoisted function instead of an inline
one in pages/admin.vue and pages/admin/datasets/[id].vue.
---
 pages/admin.vue               | 9 ++++++++-
 pages/admin/datasets/[id].vue | 9 ++++++++-
 2 files changed, 16 insertions(+), 2 deletions(-)

diff --git a/pages/admin.vue b/pages/admin.vue
index 70e150617..11be0fc78 100644
--- a/pages/admin.vue
+++ b/pages/admin.vue
@@ -44,7 +44,7 @@
     </div>
     <div class="fr-col-12 fr-col-md-8 fr-col-lg-9 fr-col-xl-10 md:h-full !px-4 sm:!px-10 pb-8 md:pb-16 lg:pb-64">
       <NuxtPage
-        :page-key="route => route.fullPath"
+        :page-key="pageKey"
       />
     </div>
   </div>
@@ -54,6 +54,7 @@
 import { Disclosure, DisclosureButton, DisclosurePanel } from '@headlessui/vue'
 import AdminSidebarMenu from '~/components/AdminSidebar/AdminSidebarMenu/AdminSidebarMenu.vue'
 import type { OrganizationReference } from '@datagouv/components-next'
+import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
   layout: 'fluid',
@@ -78,6 +79,12 @@ useSeoMeta({ title: 'Admin' })
 
 const { organizations, users } = useCurrentOwned()
 const isSiteAdmin = computed(() => me.value.roles?.includes('admin') || false)
+
+// Stable reference: NuxtPage compares page-key by reference, so an inline function here
+// would re-trigger the loading indicator on every render of this component.
+function pageKey(route: RouteLocationNormalizedLoaded) {
+  return route.fullPath
+}
 </script>
 
 <style>
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index d7f445914..57ad51771 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -126,7 +126,7 @@
       />
 
       <NuxtPage
-        :page-key="route => route.fullPath"
+        :page-key="pageKey"
         :dataset
       />
     </div>
@@ -142,6 +142,7 @@ import AdminBreadcrumb from '~/components/Breadcrumbs/AdminBreadcrumb.vue'
 import BreadcrumbItem from '~/components/Breadcrumbs/BreadcrumbItem.vue'
 import TabLinks from '~/components/TabLinks.vue'
 import type { PaginatedArray } from '~/types/types'
+import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
   keepScroll: true,
@@ -165,4 +166,10 @@ const { data: activities } = await useAPI<PaginatedArray<Activity>>('/api/1/acti
     sort: '-created_at',
   },
 })
+
+// Stable reference: NuxtPage compares page-key by reference, so an inline function here
+// would re-trigger the loading indicator whenever `dataset` changes and this re-renders.
+function pageKey(route: RouteLocationNormalizedLoaded) {
+  return route.fullPath
+}
 </script>

From 0b99b6c3608c487d62b3a24b73a261021b79ee3c Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 30 Jul 2026 16:57:44 +0200
Subject: [PATCH 02/24] feat: add geopf sync

---
 components/Datasets/FileEditModal.vue         |   6 +-
 .../Datasets/GeopfDatastoreSelector.vue       |  56 +++++
 components/Datasets/GeopfPanel.vue            |  80 +++++++
 components/Datasets/GeopfPullAction.vue       |  81 +++++++
 components/Datasets/GeopfPushButton.vue       | 128 +++++++++++
 components/Datasets/GeopfSyncPage.vue         | 217 ++++++++++++++++++
 composables/useGeopfPolling.ts                |  38 +++
 .../ResourceAccordion/EditButton.vue          |   5 +-
 .../ResourceAccordion/ResourceAccordion.vue   |   7 +
 nuxt.config.ts                                |   2 +
 pages/admin/datasets/[id].vue                 |   2 +
 pages/admin/datasets/[id]/geopf.vue           |  12 +
 plugins/api.ts                                |   6 +
 utils/geopf.ts                                | 111 +++++++++
 14 files changed, 749 insertions(+), 2 deletions(-)
 create mode 100644 components/Datasets/GeopfDatastoreSelector.vue
 create mode 100644 components/Datasets/GeopfPanel.vue
 create mode 100644 components/Datasets/GeopfPullAction.vue
 create mode 100644 components/Datasets/GeopfPushButton.vue
 create mode 100644 components/Datasets/GeopfSyncPage.vue
 create mode 100644 composables/useGeopfPolling.ts
 create mode 100644 pages/admin/datasets/[id]/geopf.vue
 create mode 100644 utils/geopf.ts

diff --git a/components/Datasets/FileEditModal.vue b/components/Datasets/FileEditModal.vue
index d239e0603..2065589eb 100644
--- a/components/Datasets/FileEditModal.vue
+++ b/components/Datasets/FileEditModal.vue
@@ -16,7 +16,8 @@
         :icon="RiPencilLine"
         :color="buttonColor"
         :size="buttonSize"
-        :title="$t('Éditer le fichier')"
+        :disabled="isSyncedWithGeopf"
+        :title="isSyncedWithGeopf ? $t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : $t('Éditer le fichier')"
         keep-margins-even-without-borders
         v-on="listeners"
       />
@@ -201,6 +202,7 @@ import DescribeResource from './DescribeResource.vue'
 import CdataLink from '../CdataLink.vue'
 import type { CommunityResourceForm, ResourceForm } from '~/types/types'
 import { useComponentsConfig } from '../../datagouv-components/src/config'
+import { isGeopfSynced } from '~/utils/geopf'
 
 const { t } = useTranslation()
 const { $api } = useNuxtApp()
@@ -232,6 +234,8 @@ const resourceForm = ref(cloneDeep(props.resource))
 const open = ref(false)
 const hasFileChanged = ref(false)
 
+const isSyncedWithGeopf = computed(() => props.resource.resource ? isGeopfSynced(props.resource.resource) : false)
+
 const hasTabularData = useHasTabularData()
 
 // Check if resource has tabular API
diff --git a/components/Datasets/GeopfDatastoreSelector.vue b/components/Datasets/GeopfDatastoreSelector.vue
new file mode 100644
index 000000000..cf2776e37
--- /dev/null
+++ b/components/Datasets/GeopfDatastoreSelector.vue
@@ -0,0 +1,56 @@
+<template>
+  <div v-if="pinnedDatastoreId">
+    <p class="text-sm text-gray-medium m-0">
+      {{ pinnedDatastoreName ? t('Entrepôt cartes.gouv.fr : {name} ({id})', { name: pinnedDatastoreName, id: pinnedDatastoreId }) : t('Entrepôt cartes.gouv.fr : {id}', { id: pinnedDatastoreId }) }}
+    </p>
+  </div>
+
+  <SelectGroup
+    v-else-if="connected === true"
+    v-model="localSelection"
+    :label="t('Entrepôt cartes.gouv.fr')"
+    :hint-text="t('Choisissez l\'entrepôt qui accueillera ce jeu de données sur cartes.gouv.fr. Ce choix ne pourra plus être modifié après le premier envoi.')"
+    :options="datastoreOptions"
+    class="max-w-sm"
+  />
+
+  <p
+    v-else
+    class="text-sm text-gray-medium m-0"
+  >
+    {{ t("Connectez-vous à cartes.gouv.fr pour choisir l'entrepôt de ce jeu de données.") }}
+  </p>
+</template>
+
+<script setup lang="ts">
+import { SelectGroup, type DatasetV2 } from '@datagouv/components-next'
+import { getGeopfDatastoreId, type GeopfDatastore } from '~/utils/geopf'
+
+const props = defineProps<{
+  dataset: DatasetV2
+  connected: boolean | null
+}>()
+
+const model = defineModel<string | null>({ default: null })
+
+const { t } = useTranslation()
+
+const pinnedDatastoreId = computed(() => getGeopfDatastoreId(props.dataset))
+
+const { data: datastores } = props.connected === true
+  ? await useAPI<Array<GeopfDatastore>>('/api/1/geopf/datastores/')
+  : { data: ref(null) }
+
+const datastoreOptions = computed(() => (datastores.value ?? []).map(datastore => ({ label: datastore.name, value: datastore.datastore_id })))
+const pinnedDatastoreName = computed(() => (datastores.value ?? []).find(datastore => datastore.datastore_id === pinnedDatastoreId.value)?.name ?? null)
+
+const localSelection = ref<string | null>(null)
+
+watch(pinnedDatastoreId, (id) => {
+  if (id) model.value = id
+}, { immediate: true })
+
+watch(localSelection, (id) => {
+  if (!pinnedDatastoreId.value) model.value = id
+})
+</script>
diff --git a/components/Datasets/GeopfPanel.vue b/components/Datasets/GeopfPanel.vue
new file mode 100644
index 000000000..174438ed8
--- /dev/null
+++ b/components/Datasets/GeopfPanel.vue
@@ -0,0 +1,80 @@
+<template>
+  <BannerAction
+    :type="bannerType"
+    :title="bannerTitle"
+  >
+    <template v-if="reauthRequired">
+      {{ t('Votre connexion a expiré ou a été révoquée.') }}
+    </template>
+    <template v-else-if="connected === false">
+      {{ t('Connectez-vous pour envoyer des fichiers et récupérer les services publiés sur cartes.gouv.fr.') }}
+    </template>
+    <template v-else-if="connected === true">
+      {{ t('Vous pouvez envoyer des fichiers vers cartes.gouv.fr depuis la liste ci-dessous.') }}
+    </template>
+
+    <template #button>
+      <a
+        v-if="connected !== true || reauthRequired"
+        class="fr-btn fr-btn--sm"
+        :href="geopfLoginUrl"
+      >
+        {{ t('Se connecter') }}
+      </a>
+      <BrandedButton
+        v-else
+        color="tertiary"
+        size="xs"
+        :icon="RiLogoutBoxLine"
+        :loading="disconnecting"
+        @click="disconnect"
+      >
+        {{ t('Se déconnecter') }}
+      </BrandedButton>
+    </template>
+  </BannerAction>
+</template>
+
+<script setup lang="ts">
+import { BannerAction, BrandedButton, toast, type DatasetV2 } from '@datagouv/components-next'
+import { RiLogoutBoxLine } from '@remixicon/vue'
+
+const props = defineProps<{
+  dataset: DatasetV2
+  connected: boolean | null
+  reauthRequired?: boolean
+}>()
+
+const emit = defineEmits<{
+  disconnected: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const config = useRuntimeConfig()
+
+const geopfLoginUrl = computed(() => `${config.public.apiBase}/api/1/geopf/login/?dataset_id=${encodeURIComponent(props.dataset.id)}`)
+
+const bannerType = computed(() => {
+  if (props.reauthRequired) return 'danger'
+  return props.connected === true ? 'primary' : 'warning'
+})
+const bannerTitle = computed(() => {
+  if (props.reauthRequired) return t('Reconnexion à cartes.gouv.fr requise')
+  return props.connected === true ? t('Connecté à cartes.gouv.fr') : t('Non connecté à cartes.gouv.fr')
+})
+
+const disconnecting = ref(false)
+
+const disconnect = async () => {
+  disconnecting.value = true
+  try {
+    await $api('/api/1/geopf/token/', { method: 'DELETE' })
+    toast.success(t('Vous êtes déconnecté de cartes.gouv.fr.'))
+    emit('disconnected')
+  }
+  finally {
+    disconnecting.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfPullAction.vue b/components/Datasets/GeopfPullAction.vue
new file mode 100644
index 000000000..dd2a11d9f
--- /dev/null
+++ b/components/Datasets/GeopfPullAction.vue
@@ -0,0 +1,81 @@
+<template>
+  <div class="flex flex-col items-end gap-1">
+    <component :is="disabledReason ? Tooltip : 'div'">
+      <BrandedButton
+        color="secondary"
+        size="xs"
+        :icon="RiDownloadCloud2Line"
+        :disabled="!!disabledReason"
+        :loading="pulling || pullState.status === 'pending'"
+        @click="pull"
+      >
+        {{ t('Récupérer les services') }}
+      </BrandedButton>
+
+      <template #tooltip>
+        {{ disabledReason }}
+      </template>
+    </component>
+
+    <span
+      v-if="pullState.status === 'done' && pullState.lastSyncedAt"
+      class="text-xs text-gray-medium"
+    >
+      {{ t('Dernière synchronisation : {date}', { date: formatDate(pullState.lastSyncedAt) }) }}
+    </span>
+    <span
+      v-else-if="pullState.status === 'error'"
+      class="text-xs text-new-error"
+    >
+      {{ pullState.error }}
+    </span>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, Tooltip, useFormatDate, type DatasetV2 } from '@datagouv/components-next'
+import { RiDownloadCloud2Line } from '@remixicon/vue'
+import { getGeopfFicheUrl, getGeopfPullState, isGeopfReauthRequired } from '~/utils/geopf'
+
+const props = defineProps<{
+  dataset: DatasetV2
+  connected: boolean | null
+}>()
+
+const emit = defineEmits<{
+  pulled: []
+  reauthRequired: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+
+const ficheUrl = computed(() => getGeopfFicheUrl(props.dataset))
+const pullState = computed(() => getGeopfPullState(props.dataset))
+
+const disabledReason = computed(() => {
+  if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour récupérer les services.')
+  if (!ficheUrl.value) return t('Envoyez d\'abord un fichier au format GeoPackage (.gpkg) vers cartes.gouv.fr.')
+  return null
+})
+
+const pulling = ref(false)
+
+const pull = async () => {
+  pulling.value = true
+  try {
+    await $api(`/api/1/geopf/pull-offerings/${props.dataset.id}/`, { method: 'POST' })
+    emit('pulled')
+  }
+  catch (error) {
+    if (isGeopfReauthRequired(error)) {
+      emit('reauthRequired')
+    }
+    // Otherwise plugins/api.ts already toasted the error.
+  }
+  finally {
+    pulling.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfPushButton.vue b/components/Datasets/GeopfPushButton.vue
new file mode 100644
index 000000000..a86d6a770
--- /dev/null
+++ b/components/Datasets/GeopfPushButton.vue
@@ -0,0 +1,128 @@
+<template>
+  <component
+    :is="disabledReason ? Tooltip : 'div'"
+    v-if="pushState.status === null"
+  >
+    <BrandedButton
+      color="secondary"
+      size="xs"
+      :icon="RiUploadCloud2Line"
+      :disabled="!!disabledReason"
+      :loading="pushing"
+      @click="push"
+    >
+      {{ t('Envoyer vers cartes.gouv.fr') }}
+    </BrandedButton>
+
+    <template #tooltip>
+      {{ disabledReason }}
+    </template>
+  </component>
+
+  <AdminBadge
+    v-else-if="pushState.status === 'pending'"
+    size="xs"
+    :type="getGeopfBadgeType(pushState.status)"
+  >
+    {{ t('Envoi en cours…') }}
+  </AdminBadge>
+
+  <div
+    v-else-if="pushState.status === 'done'"
+    class="flex flex-col items-start"
+  >
+    <AdminBadge
+      size="xs"
+      :type="getGeopfBadgeType(pushState.status)"
+    >
+      {{ t('Synchronisé') }}
+    </AdminBadge>
+    <span
+      v-if="pushState.lastSyncedAt"
+      class="text-xs text-gray-medium"
+    >
+      {{ formatDate(pushState.lastSyncedAt) }}
+    </span>
+  </div>
+
+  <div
+    v-else
+    class="flex flex-col items-start gap-1"
+  >
+    <Tooltip>
+      <AdminBadge
+        size="xs"
+        :type="getGeopfBadgeType(pushState.status)"
+      >
+        {{ pushState.status === 'timeout' ? t('Délai dépassé') : t("Échec de l'envoi") }}
+      </AdminBadge>
+
+      <template #tooltip>
+        {{ pushState.error }}
+      </template>
+    </Tooltip>
+
+    <BrandedButton
+      color="tertiary"
+      size="xs"
+      :icon="RiRefreshLine"
+      :disabled="!!disabledReason"
+      :loading="pushing"
+      @click="push"
+    >
+      {{ t('Réessayer') }}
+    </BrandedButton>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, Tooltip, useFormatDate, type Resource } from '@datagouv/components-next'
+import { RiRefreshLine, RiUploadCloud2Line } from '@remixicon/vue'
+import { getGeopfBadgeType, getGeopfPushState, isGeopfReauthRequired } from '~/utils/geopf'
+
+const props = defineProps<{
+  resource: Resource
+  datasetId: string
+  connected: boolean | null
+  datastoreId: string | null
+}>()
+
+const emit = defineEmits<{
+  pushed: []
+  reauthRequired: []
+}>()
+
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+
+const pushState = computed(() => getGeopfPushState(props.resource))
+
+const disabledReason = computed(() => {
+  if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour envoyer ce fichier.')
+  if (!props.datastoreId) return t('Choisissez d\'abord l\'entrepôt cartes.gouv.fr de ce jeu de données.')
+  return null
+})
+
+const pushing = ref(false)
+
+const push = async () => {
+  pushing.value = true
+  try {
+    await $api(`/api/1/geopf/push/${props.datasetId}/${props.resource.id}/`, {
+      method: 'POST',
+      body: { datastore_id: props.datastoreId },
+    })
+    emit('pushed')
+  }
+  catch (error) {
+    if (isGeopfReauthRequired(error)) {
+      emit('reauthRequired')
+    }
+    // Otherwise plugins/api.ts already toasted the error.
+  }
+  finally {
+    pushing.value = false
+  }
+}
+</script>
diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
new file mode 100644
index 000000000..087f73016
--- /dev/null
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -0,0 +1,217 @@
+<template>
+  <div class="bg-white fr-p-3w">
+    <template v-if="canEdit">
+      <GeopfPanel
+        v-if="dataset"
+        :dataset="dataset"
+        :connected="isGeopfConnected"
+        :reauth-required="reauthRequired"
+        class="fr-mb-3w"
+        @disconnected="onGeopfDisconnected"
+      />
+
+      <GeopfDatastoreSelector
+        v-if="dataset"
+        v-model="datastoreId"
+        :dataset="dataset"
+        :connected="isGeopfConnected"
+        class="fr-mb-3w"
+      />
+
+      <LoadingBlock
+        v-slot="{ data: loadedResourcesPage }"
+        :status
+        :data="resourcesPage"
+      >
+        <h2 class="text-sm font-bold uppercase">
+          {{ t('Fichiers à envoyer') }}
+        </h2>
+        <AdminTable v-if="loadedResourcesPage && pushableResources.length">
+          <thead>
+            <tr>
+              <AdminTableTh scope="col">
+                {{ t('Nom du fichier') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Format') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Envoi') }}
+              </AdminTableTh>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="resource in pushableResources"
+              :key="resource.id"
+            >
+              <td>
+                <TextClamp
+                  :text="resource.title"
+                  :auto-resize="true"
+                  :max-lines="2"
+                />
+              </td>
+              <td>
+                {{ resource.format }}
+              </td>
+              <td>
+                <GeopfPushButton
+                  v-if="dataset"
+                  :resource="resource"
+                  :dataset-id="dataset.id"
+                  :connected="isGeopfConnected"
+                  :datastore-id="datastoreId"
+                  @pushed="onGeopfPushed"
+                  @reauth-required="reauthRequired = true"
+                />
+              </td>
+            </tr>
+          </tbody>
+        </AdminTable>
+        <p
+          v-else
+          class="text-sm text-gray-medium m-0"
+        >
+          {{ t("Aucun fichier au format GeoPackage (.gpkg) n'a été trouvé dans ce jeu de données.") }}
+        </p>
+
+        <div class="flex flex-wrap justify-between items-start gap-2 mt-8 mb-3">
+          <h2 class="text-sm font-bold uppercase m-0">
+            {{ t('Services récupérés depuis cartes.gouv.fr') }}
+          </h2>
+          <GeopfPullAction
+            v-if="dataset"
+            :dataset="dataset"
+            :connected="isGeopfConnected"
+            @pulled="onGeopfPulled"
+            @reauth-required="reauthRequired = true"
+          />
+        </div>
+        <AdminTable v-if="loadedResourcesPage && syncedResources.length">
+          <thead>
+            <tr>
+              <AdminTableTh scope="col">
+                {{ t('Nom') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Format') }}
+              </AdminTableTh>
+              <AdminTableTh scope="col">
+                {{ t('Dernière synchronisation') }}
+              </AdminTableTh>
+            </tr>
+          </thead>
+          <tbody>
+            <tr
+              v-for="resource in syncedResources"
+              :key="resource.id"
+            >
+              <td>
+                <TextClamp
+                  :text="resource.title"
+                  :auto-resize="true"
+                  :max-lines="2"
+                />
+              </td>
+              <td>
+                {{ resource.format }}
+              </td>
+              <td>
+                {{ formatDate(getGeopfOfferingLastSyncedAt(resource)) }}
+              </td>
+            </tr>
+          </tbody>
+        </AdminTable>
+        <p
+          v-else
+          class="text-sm text-gray-medium m-0"
+        >
+          {{ t("Aucun service n'a encore été synchronisé depuis cartes.gouv.fr.") }}
+        </p>
+
+        <BrandedButton
+          v-if="ficheUrl"
+          color="secondary"
+          size="xs"
+          :href="ficheUrl"
+          new-tab
+          class="mt-3"
+        >
+          {{ t('Voir la fiche sur cartes.gouv.fr') }}
+        </BrandedButton>
+      </LoadingBlock>
+    </template>
+    <p
+      v-else
+      class="text-sm text-gray-medium m-0"
+    >
+      {{ t('Vous n\'avez pas la permission de synchroniser ce jeu de données avec cartes.gouv.fr.') }}
+    </p>
+  </div>
+</template>
+
+<script setup lang="ts">
+import { BrandedButton, LoadingBlock, useFormatDate, type DatasetV2, type Resource } from '@datagouv/components-next'
+import GeopfDatastoreSelector from './GeopfDatastoreSelector.vue'
+import GeopfPanel from './GeopfPanel.vue'
+import GeopfPullAction from './GeopfPullAction.vue'
+import GeopfPushButton from './GeopfPushButton.vue'
+import AdminTable from '../AdminTable/Table/AdminTable.vue'
+import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
+import type { PaginatedArray } from '~/types/types'
+import { getGeopfFicheUrl, getGeopfOfferingLastSyncedAt, getGeopfPullState, getGeopfPushState, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
+
+// Large enough to cover a typical dataset's gpkg/offering resources in one request:
+// this view only lists a small subset (eligible resources), so full pagination
+// isn't needed, unlike the main Fichiers tab.
+const GEOPF_LIST_PAGE_SIZE = 100
+
+const route = useRoute()
+const { $api } = useNuxtApp()
+const { t } = useTranslation()
+const { formatDate } = useFormatDate()
+const config = useRuntimeConfig()
+
+const datasetUrl = computed(() => `/api/2/datasets/${route.params.id}/`)
+const { data: dataset, status, refresh: refreshDataset } = await useAPI<DatasetV2>(datasetUrl, {
+  redirectOn404: true,
+  headers: {
+    'X-Get-Datasets-Full-Objects': 'True',
+  },
+})
+const canEdit = computed(() => dataset.value?.permissions.edit_resources ?? false)
+const ficheUrl = computed(() => dataset.value ? getGeopfFicheUrl(dataset.value) : null)
+
+const { data: geopfConnected } = config.public.geopfEnabled
+  ? await useAPI<{ connected: boolean, expires_at: string | null }>('/api/1/geopf/status/')
+  : { data: ref(null) }
+const isGeopfConnected = computed(() => geopfConnected.value?.connected ?? null)
+const reauthRequired = ref(false)
+const datastoreId = ref<string | null>(null)
+
+const resourcesPage = ref<PaginatedArray<Resource> | null>(null)
+const refreshResources = async () => {
+  if (!dataset.value) return
+  resourcesPage.value = await $api<PaginatedArray<Resource>>(dataset.value.resources.href, { query: { page_size: GEOPF_LIST_PAGE_SIZE } })
+}
+watchEffect(async () => await refreshResources())
+
+const pushableResources = computed(() => (resourcesPage.value?.data ?? []).filter(isGeopfPushable))
+const syncedResources = computed(() => (resourcesPage.value?.data ?? []).filter(isGeopfOffering))
+
+const geopfPending = computed(() => {
+  const pushPending = pushableResources.value.some(r => getGeopfPushState(r).status === 'pending')
+  const pullPending = dataset.value ? getGeopfPullState(dataset.value).status === 'pending' : false
+  return pushPending || pullPending
+})
+useGeopfPolling(geopfPending, async () => {
+  await Promise.all([refreshResources(), refreshDataset()])
+})
+
+const onGeopfPulled = async () => await Promise.all([refreshDataset(), refreshResources()])
+// A push can also write dataset-level extras (fiche-url, pinned datastore-id) on its
+// first success, so refresh both here too — not just the resource that was pushed.
+const onGeopfPushed = async () => await Promise.all([refreshDataset(), refreshResources()])
+const onGeopfDisconnected = () => reloadNuxtApp({ path: route.fullPath })
+</script>
diff --git a/composables/useGeopfPolling.ts b/composables/useGeopfPolling.ts
new file mode 100644
index 000000000..8a3bedfa8
--- /dev/null
+++ b/composables/useGeopfPolling.ts
@@ -0,0 +1,38 @@
+import { useIntervalFn } from '@vueuse/core'
+import type { ComputedRef } from 'vue'
+
+const POLL_INTERVAL_MS = 8000
+// Push can span roughly two server-side poll timeouts (see udata/docs/geopf.md);
+// this is a client-side ceiling, not a failure signal — the extras stay the
+// source of truth, a manual reload still picks up the eventual terminal status.
+const MAX_POLL_DURATION_MS = 5 * 60 * 1000
+
+export function useGeopfPolling(pending: ComputedRef<boolean>, tick: () => Promise<void>) {
+  const timedOut = ref(false)
+  let elapsed = 0
+
+  const { pause, resume, isActive } = useIntervalFn(async () => {
+    elapsed += POLL_INTERVAL_MS
+    if (elapsed >= MAX_POLL_DURATION_MS) {
+      timedOut.value = true
+      pause()
+      return
+    }
+    await tick()
+  }, POLL_INTERVAL_MS, { immediate: false })
+
+  watch(pending, (isPending) => {
+    if (isPending) {
+      elapsed = 0
+      timedOut.value = false
+      resume()
+    }
+    else {
+      pause()
+    }
+  }, { immediate: true })
+
+  onUnmounted(() => pause())
+
+  return { isPolling: isActive, timedOut }
+}
diff --git a/datagouv-components/src/components/ResourceAccordion/EditButton.vue b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
index 4f8554255..aa02ec893 100644
--- a/datagouv-components/src/components/ResourceAccordion/EditButton.vue
+++ b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
@@ -4,7 +4,8 @@
     icon-only
     :icon="RiPencilLine"
     color="warning"
-    :title="t('Éditer le fichier')"
+    :disabled="disabled"
+    :title="disabled ? t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : t('Éditer le fichier')"
     data-testid="edit-button"
   />
 </template>
@@ -19,10 +20,12 @@ type Props = {
   datasetId: string
   isCommunityResource?: boolean
   resourceId: string
+  disabled?: boolean
 }
 
 const props = withDefaults(defineProps<Props>(), {
   isCommunityResource: false,
+  disabled: false,
 })
 
 const { t } = useTranslation()
diff --git a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
index a5f19b12a..40409fe37 100644
--- a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
+++ b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
@@ -163,6 +163,7 @@
             :dataset-id="dataset.id"
             :resource-id="resource.id"
             :is-community-resource="isCommunityResource"
+            :disabled="isGeopfSynced"
             size="xs"
           />
         </p>
@@ -369,6 +370,12 @@ const hasPmtiles = computed(() => {
   return props.resource.extras['analysis:parsing:pmtiles_url'] || props.resource.format === 'pmtiles'
 })
 
+// A resource successfully pushed to, or pulled back from, Géoplateforme shouldn't be
+// edited locally: doing so would silently diverge from what's published on cartes.gouv.fr.
+const isGeopfSynced = computed(() => {
+  return props.resource.extras['geopf:push:status'] === 'done' || typeof props.resource.extras['geopf:offering:id'] === 'string'
+})
+
 const hasDatafairPreview = computed(() => {
   // Checks if there are the corresponding extras for a datafair preview.
   // Limited only to datasets published by certified organizations since it will load an iframe.
diff --git a/nuxt.config.ts b/nuxt.config.ts
index 72dfde63d..e083181b4 100644
--- a/nuxt.config.ts
+++ b/nuxt.config.ts
@@ -170,6 +170,8 @@ export default defineNuxtConfig({
       resourceFileUploadChunk: 2 * 1000 * 1000,
       maxSortableFiles: 50,
 
+      geopfEnabled: false,
+
       maxNumberOfDatasetsForDataserviceUpdate: 200,
 
       captcheta: {
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 57ad51771..381257f10 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -122,6 +122,7 @@
           { href: `${getDatasetAdminUrl(dataset)}/files`, label: t('Fichiers') },
           { href: `${getDatasetAdminUrl(dataset)}/discussions`, label: t('Discussions') },
           { href: `${getDatasetAdminUrl(dataset)}/activities`, label: t('Activités'), show: dataset.permissions.edit },
+          { href: `${getDatasetAdminUrl(dataset)}/geopf`, label: t('Synchronisation cartes.gouv.fr'), show: config.public.geopfEnabled && dataset.permissions.edit_resources },
         ]"
       />
 
@@ -150,6 +151,7 @@ definePageMeta({
 
 const { t } = useTranslation()
 const me = useMe()
+const config = useRuntimeConfig()
 
 const route = useRoute()
 const { formatDate } = useFormatDate()
diff --git a/pages/admin/datasets/[id]/geopf.vue b/pages/admin/datasets/[id]/geopf.vue
new file mode 100644
index 000000000..08a8ac1c5
--- /dev/null
+++ b/pages/admin/datasets/[id]/geopf.vue
@@ -0,0 +1,12 @@
+<template>
+  <GeopfSyncPage />
+</template>
+
+<script setup lang="ts">
+import type { DatasetV2 } from '@datagouv/components-next'
+import GeopfSyncPage from '~/components/Datasets/GeopfSyncPage.vue'
+
+defineProps<{
+  dataset: DatasetV2
+}>()
+</script>
diff --git a/plugins/api.ts b/plugins/api.ts
index c16ecdb32..fe3c1e6ab 100644
--- a/plugins/api.ts
+++ b/plugins/api.ts
@@ -56,6 +56,12 @@ export default defineNuxtPlugin({
             }
           }
 
+          if (response.status === 409) {
+            // Used by geopf push/pull to mean "not connected": callers handle this
+            // themselves (prompt to reconnect) instead of a generic toast.
+            return
+          }
+
           if (response.status === 429) {
             toast.error(t('Erreur API 429 : trop de requêtes. Veuillez réessayer plus tard.'))
             return
diff --git a/utils/geopf.ts b/utils/geopf.ts
new file mode 100644
index 000000000..4e41d3dea
--- /dev/null
+++ b/utils/geopf.ts
@@ -0,0 +1,111 @@
+import type { DatasetV2, Resource } from '@datagouv/components-next'
+import type { AdminBadgeType } from '~/types/types'
+
+// Only gpkg is processed by the udata geopf plugin today (GEOPF_PUSHABLE_FORMATS),
+// and it isn't exposed by any API endpoint, so this is a known, documented coupling
+// with the backend config: see udata/docs/geopf.md.
+export const GEOPF_PUSHABLE_FORMAT = 'gpkg'
+
+export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
+export type GeopfPullStatus = 'pending' | 'done' | 'error'
+
+export function isGeopfPushable(resource: Resource): boolean {
+  return resource.format?.toLowerCase() === GEOPF_PUSHABLE_FORMAT && !isGeopfOffering(resource)
+}
+
+export function isGeopfOffering(resource: Resource): boolean {
+  return typeof resource.extras['geopf:offering:id'] === 'string'
+}
+
+export function getGeopfOfferingLastSyncedAt(resource: Resource): string | null {
+  return (resource.extras['geopf:offering:last-synced-at'] as string | undefined) ?? null
+}
+
+// A resource tied into the Géoplateforme sync (successfully pushed, or pulled back
+// as an offering) shouldn't be edited/replaced locally: doing so would silently
+// diverge from what's published on cartes.gouv.fr.
+export function isGeopfSynced(resource: Resource): boolean {
+  return resource.extras['geopf:push:status'] === 'done' || isGeopfOffering(resource)
+}
+
+export type GeopfPushState
+  = | { status: null }
+    | { status: 'pending' }
+    | { status: 'done', lastSyncedAt: string | null }
+    | { status: 'error' | 'timeout', error: string | null }
+
+export function getGeopfPushState(resource: Resource): GeopfPushState {
+  const status = resource.extras['geopf:push:status'] as GeopfPushStatus | undefined
+
+  if (status === 'done') {
+    return { status: 'done', lastSyncedAt: (resource.extras['geopf:push:last-synced-at'] as string | undefined) ?? null }
+  }
+  if (status === 'error' || status === 'timeout') {
+    return { status, error: (resource.extras['geopf:push:error'] as string | undefined) ?? null }
+  }
+  if (status === 'pending') {
+    return { status: 'pending' }
+  }
+  return { status: null }
+}
+
+export type GeopfPullState
+  = | { status: null }
+    | { status: 'pending' }
+    | { status: 'done', lastSyncedAt: string | null }
+    | { status: 'error', error: string | null }
+
+export function getGeopfPullState(dataset: DatasetV2): GeopfPullState {
+  const status = dataset.extras['geopf:pull:status'] as GeopfPullStatus | undefined
+
+  if (status === 'done') {
+    return { status: 'done', lastSyncedAt: (dataset.extras['geopf:pull:last-synced-at'] as string | undefined) ?? null }
+  }
+  if (status === 'error') {
+    return { status: 'error', error: (dataset.extras['geopf:pull:error'] as string | undefined) ?? null }
+  }
+  if (status === 'pending') {
+    return { status: 'pending' }
+  }
+  return { status: null }
+}
+
+export function getGeopfFicheUrl(dataset: DatasetV2): string | null {
+  return (dataset.extras['geopf:push:fiche-url'] as string | undefined) ?? null
+}
+
+// A dataset lives in exactly one entrepôt: this is pinned in dataset extras on
+// the first *successful* push and reused as-is by every later push (see
+// udata/docs/geopf.md). Not editable once set.
+export function getGeopfDatastoreId(dataset: DatasetV2): string | null {
+  return (dataset.extras['geopf:push:datastore-id'] as string | undefined) ?? null
+}
+
+// Raw pass-through of geopf's own API shape (GET /datastores).
+export type GeopfDatastore = {
+  datastore_id: string
+  name: string
+}
+
+// 409 means "not connected to Géoplateforme" for both push and pull (see udata/docs/geopf.md);
+// the global $api error handler swallows it silently, so callers check it themselves
+// to prompt reconnection instead of failing silently.
+export function isGeopfReauthRequired(error: unknown): boolean {
+  if (!error || typeof error !== 'object' || !('response' in error)) return false
+  const response = (error as { response?: { status?: number } }).response
+  return response?.status === 409
+}
+
+export function getGeopfBadgeType(status: GeopfPushStatus | GeopfPullStatus | null): AdminBadgeType {
+  switch (status) {
+    case 'done':
+      return 'success'
+    case 'pending':
+      return 'primary'
+    case 'error':
+    case 'timeout':
+      return 'danger'
+    default:
+      return 'secondary'
+  }
+}

From 55299ee50944e4ba656d8de7887fb03398fe16dd Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Fri, 31 Jul 2026 10:06:18 +0200
Subject: [PATCH 03/24] 409 -> 424

---
 plugins/api.ts | 2 +-
 utils/geopf.ts | 4 ++--
 2 files changed, 3 insertions(+), 3 deletions(-)

diff --git a/plugins/api.ts b/plugins/api.ts
index fe3c1e6ab..2932ff356 100644
--- a/plugins/api.ts
+++ b/plugins/api.ts
@@ -56,7 +56,7 @@ export default defineNuxtPlugin({
             }
           }
 
-          if (response.status === 409) {
+          if (response.status === 424) {
             // Used by geopf push/pull to mean "not connected": callers handle this
             // themselves (prompt to reconnect) instead of a generic toast.
             return
diff --git a/utils/geopf.ts b/utils/geopf.ts
index 4e41d3dea..cc589ba95 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -87,13 +87,13 @@ export type GeopfDatastore = {
   name: string
 }
 
-// 409 means "not connected to Géoplateforme" for both push and pull (see udata/docs/geopf.md);
+// 424 means "not connected to Géoplateforme" for both push and pull (see udata/docs/geopf.md);
 // the global $api error handler swallows it silently, so callers check it themselves
 // to prompt reconnection instead of failing silently.
 export function isGeopfReauthRequired(error: unknown): boolean {
   if (!error || typeof error !== 'object' || !('response' in error)) return false
   const response = (error as { response?: { status?: number } }).response
-  return response?.status === 409
+  return response?.status === 424
 }
 
 export function getGeopfBadgeType(status: GeopfPushStatus | GeopfPullStatus | null): AdminBadgeType {

From a9b9672f5b7f6fee69e64cc61b208a100f7f6078 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Fri, 14 Aug 2026 11:05:08 +0200
Subject: [PATCH 04/24] conditionnal tab on eligible resources

---
 .../Datasets/AdminDatasetResourcesPage.vue      |  3 +++
 components/Datasets/GeopfSyncPage.vue           |  7 +------
 .../Datasets/geopfEligibilityRefreshKey.ts      |  7 +++++++
 pages/admin/datasets/[id].vue                   | 17 +++++++++++++++--
 utils/geopf.ts                                  |  4 ++++
 5 files changed, 30 insertions(+), 8 deletions(-)
 create mode 100644 components/Datasets/geopfEligibilityRefreshKey.ts

diff --git a/components/Datasets/AdminDatasetResourcesPage.vue b/components/Datasets/AdminDatasetResourcesPage.vue
index 84dcf8c53..2839ea5de 100644
--- a/components/Datasets/AdminDatasetResourcesPage.vue
+++ b/components/Datasets/AdminDatasetResourcesPage.vue
@@ -214,6 +214,7 @@ import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
 import UploadResourceModal from './UploadResourceModal.vue'
 import FileEditModal from './FileEditModal.vue'
 import FileEditModalFromQueryStringClient from './FileEditModalFromQueryString.client.vue'
+import { geopfEligibilityRefreshKey } from './geopfEligibilityRefreshKey'
 import type { AdminBadgeType, CommunityResourceForm, PaginatedArray, ResourceForm } from '~/types/types'
 
 const route = useRoute()
@@ -242,9 +243,11 @@ const params = computed(() => {
   }
 })
 
+const refreshGeopfEligibility = inject(geopfEligibilityRefreshKey, () => {})
 const refreshResources = async () => {
   if (!dataset.value) return
   resourcesPage.value = await $api<PaginatedArray<Resource>>(dataset.value.resources.href, { query: params.value })
+  refreshGeopfEligibility()
 }
 watchEffect(async () => await refreshResources())
 
diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index 087f73016..1cf922623 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -160,12 +160,7 @@ import GeopfPushButton from './GeopfPushButton.vue'
 import AdminTable from '../AdminTable/Table/AdminTable.vue'
 import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
 import type { PaginatedArray } from '~/types/types'
-import { getGeopfFicheUrl, getGeopfOfferingLastSyncedAt, getGeopfPullState, getGeopfPushState, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
-
-// Large enough to cover a typical dataset's gpkg/offering resources in one request:
-// this view only lists a small subset (eligible resources), so full pagination
-// isn't needed, unlike the main Fichiers tab.
-const GEOPF_LIST_PAGE_SIZE = 100
+import { GEOPF_LIST_PAGE_SIZE, getGeopfFicheUrl, getGeopfOfferingLastSyncedAt, getGeopfPullState, getGeopfPushState, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
 
 const route = useRoute()
 const { $api } = useNuxtApp()
diff --git a/components/Datasets/geopfEligibilityRefreshKey.ts b/components/Datasets/geopfEligibilityRefreshKey.ts
new file mode 100644
index 000000000..0511bd9c2
--- /dev/null
+++ b/components/Datasets/geopfEligibilityRefreshKey.ts
@@ -0,0 +1,7 @@
+import type { InjectionKey } from 'vue'
+
+// Lets the Files tab (which mutates resources) tell the admin dataset layout
+// (which decides whether the geopf tab is shown) to recheck eligibility, so a
+// newly-added resource surfaces the tab without a full page reload.
+export type GeopfEligibilityRefresh = () => void
+export const geopfEligibilityRefreshKey = Symbol() as InjectionKey<GeopfEligibilityRefresh>
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 381257f10..7d6a29212 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -122,7 +122,7 @@
           { href: `${getDatasetAdminUrl(dataset)}/files`, label: t('Fichiers') },
           { href: `${getDatasetAdminUrl(dataset)}/discussions`, label: t('Discussions') },
           { href: `${getDatasetAdminUrl(dataset)}/activities`, label: t('Activités'), show: dataset.permissions.edit },
-          { href: `${getDatasetAdminUrl(dataset)}/geopf`, label: t('Synchronisation cartes.gouv.fr'), show: config.public.geopfEnabled && dataset.permissions.edit_resources },
+          { href: `${getDatasetAdminUrl(dataset)}/geopf`, label: t('Synchronisation cartes.gouv.fr'), show: config.public.geopfEnabled && dataset.permissions.edit_resources && hasEligibleGeopfResource },
         ]"
       />
 
@@ -136,13 +136,15 @@
 
 <script setup lang="ts">
 import { BrandedButton, DatasetQualityTooltipContent, QualityScore, summarize, useFormatDate, AvatarWithName, Tooltip, getActivityTranslation } from '@datagouv/components-next'
-import type { Activity, DatasetV2WithFullObject } from '@datagouv/components-next'
+import type { Activity, DatasetV2WithFullObject, Resource } from '@datagouv/components-next'
 import { RiBarChartBoxLine, RiCalendarLine, RiDownloadLine, RiEyeLine, RiLineChartLine, RiPriceTag3Line, RiStarLine } from '@remixicon/vue'
 import DatasetBadge from '~/components/AdminBadge/DatasetBadge.vue'
 import AdminBreadcrumb from '~/components/Breadcrumbs/AdminBreadcrumb.vue'
 import BreadcrumbItem from '~/components/Breadcrumbs/BreadcrumbItem.vue'
 import TabLinks from '~/components/TabLinks.vue'
+import { geopfEligibilityRefreshKey } from '~/components/Datasets/geopfEligibilityRefreshKey'
 import type { PaginatedArray } from '~/types/types'
+import { GEOPF_LIST_PAGE_SIZE, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
 import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
@@ -169,6 +171,17 @@ const { data: activities } = await useAPI<PaginatedArray<Activity>>('/api/1/acti
   },
 })
 
+// Fetched only to decide whether the geopf tab is worth showing: a dataset with no
+// gpkg resource and nothing pulled back from cartes.gouv.fr has nothing to do there.
+const { data: geopfResources, refresh: refreshGeopfResources } = config.public.geopfEnabled
+  ? await useAPI<PaginatedArray<Resource>>(computed(() => dataset.value?.resources.href ?? ''), { query: { page_size: GEOPF_LIST_PAGE_SIZE } })
+  : { data: ref(null), refresh: async () => {} }
+const hasEligibleGeopfResource = computed(() => (geopfResources.value?.data ?? []).some(r => isGeopfPushable(r) || isGeopfOffering(r)))
+
+// The Files tab (a NuxtPage descendant) calls this after any resource change, so
+// a newly-uploaded gpkg makes the tab appear without a full page reload.
+provide(geopfEligibilityRefreshKey, () => refreshGeopfResources())
+
 // Stable reference: NuxtPage compares page-key by reference, so an inline function here
 // would re-trigger the loading indicator whenever `dataset` changes and this re-renders.
 function pageKey(route: RouteLocationNormalizedLoaded) {
diff --git a/utils/geopf.ts b/utils/geopf.ts
index cc589ba95..ea1b641e5 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -9,6 +9,10 @@ export const GEOPF_PUSHABLE_FORMAT = 'gpkg'
 export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
 export type GeopfPullStatus = 'pending' | 'done' | 'error'
 
+// Large enough to cover a typical dataset's gpkg/offering resources in one request,
+// since only this small subset (eligible resources) is relevant to geopf sync.
+export const GEOPF_LIST_PAGE_SIZE = 100
+
 export function isGeopfPushable(resource: Resource): boolean {
   return resource.format?.toLowerCase() === GEOPF_PUSHABLE_FORMAT && !isGeopfOffering(resource)
 }

From bcc11a405967f9d637ec02808e20a80b1e623311 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 15:56:42 +0200
Subject: [PATCH 05/24] refactor around new status endpoint

---
 .../Datasets/AdminDatasetResourcesPage.vue    |  18 ++-
 .../Datasets/GeopfDatastoreSelector.vue       |  15 ++-
 components/Datasets/GeopfPanel.vue            |   7 +-
 components/Datasets/GeopfPullAction.vue       |  34 +++---
 components/Datasets/GeopfPushButton.vue       |  40 +++---
 components/Datasets/GeopfSyncPage.vue         |  78 +++++-------
 .../ResourceAccordion/ResourceAccordion.vue   |   6 +-
 pages/admin/datasets/[id].vue                 |  19 +--
 pages/admin/datasets/[id]/geopf.vue           |   1 +
 utils/geopf.ts                                | 114 +++++++-----------
 10 files changed, 151 insertions(+), 181 deletions(-)

diff --git a/components/Datasets/AdminDatasetResourcesPage.vue b/components/Datasets/AdminDatasetResourcesPage.vue
index 2839ea5de..5515011ed 100644
--- a/components/Datasets/AdminDatasetResourcesPage.vue
+++ b/components/Datasets/AdminDatasetResourcesPage.vue
@@ -78,7 +78,7 @@
       :schemas="schemas ?? []"
       :dataset
       @submit="updateResource"
-      @delete="refreshResources"
+      @delete="refreshAfterMutation"
     />
 
     <LoadingBlock
@@ -187,7 +187,7 @@
                 :loading
                 :resource="resourceToForm(resource, schemas ?? [])"
                 @submit="updateResource"
-                @delete="refreshResources"
+                @delete="refreshAfterMutation"
               />
             </td>
           </tr>
@@ -243,14 +243,20 @@ const params = computed(() => {
   }
 })
 
-const refreshGeopfEligibility = inject(geopfEligibilityRefreshKey, () => {})
 const refreshResources = async () => {
   if (!dataset.value) return
   resourcesPage.value = await $api<PaginatedArray<Resource>>(dataset.value.resources.href, { query: params.value })
-  refreshGeopfEligibility()
 }
 watchEffect(async () => await refreshResources())
 
+// Kept off `refreshResources`, which the watchEffect above also runs on every
+// pagination change.
+const refreshGeopfEligibility = inject(geopfEligibilityRefreshKey, () => {})
+const refreshAfterMutation = async () => {
+  await refreshResources()
+  refreshGeopfEligibility()
+}
+
 const { t } = useTranslation()
 
 const resourceForms = ref<Array<ResourceForm>>([])
@@ -275,7 +281,7 @@ const saveFirstNewFile = async (closeModal: () => void, form: ResourceForm | Com
   removeFirstNewFile()
 
   page.value = 1
-  refreshResources()
+  refreshAfterMutation()
 }
 const updateResource = async (closeModal: () => void, resourceForm: ResourceForm | CommunityResourceForm) => {
   if (!dataset.value) return
@@ -283,7 +289,7 @@ const updateResource = async (closeModal: () => void, resourceForm: ResourceForm
 
   try {
     await saveResourceForm(dataset.value, resourceForm)
-    await refreshResources()
+    await refreshAfterMutation()
     closeModal()
   }
   finally {
diff --git a/components/Datasets/GeopfDatastoreSelector.vue b/components/Datasets/GeopfDatastoreSelector.vue
index cf2776e37..51d8c694d 100644
--- a/components/Datasets/GeopfDatastoreSelector.vue
+++ b/components/Datasets/GeopfDatastoreSelector.vue
@@ -23,11 +23,12 @@
 </template>
 
 <script setup lang="ts">
-import { SelectGroup, type DatasetV2 } from '@datagouv/components-next'
-import { getGeopfDatastoreId, type GeopfDatastore } from '~/utils/geopf'
+import { SelectGroup } from '@datagouv/components-next'
+import type { GeopfDatastore } from '~/utils/geopf'
 
 const props = defineProps<{
-  dataset: DatasetV2
+  // Set on the dataset's first successful push, not editable afterwards.
+  pinnedDatastoreId: string | null
   connected: boolean | null
 }>()
 
@@ -35,22 +36,20 @@ const model = defineModel<string | null>({ default: null })
 
 const { t } = useTranslation()
 
-const pinnedDatastoreId = computed(() => getGeopfDatastoreId(props.dataset))
-
 const { data: datastores } = props.connected === true
   ? await useAPI<Array<GeopfDatastore>>('/api/1/geopf/datastores/')
   : { data: ref(null) }
 
 const datastoreOptions = computed(() => (datastores.value ?? []).map(datastore => ({ label: datastore.name, value: datastore.datastore_id })))
-const pinnedDatastoreName = computed(() => (datastores.value ?? []).find(datastore => datastore.datastore_id === pinnedDatastoreId.value)?.name ?? null)
+const pinnedDatastoreName = computed(() => (datastores.value ?? []).find(datastore => datastore.datastore_id === props.pinnedDatastoreId)?.name ?? null)
 
 const localSelection = ref<string | null>(null)
 
-watch(pinnedDatastoreId, (id) => {
+watch(() => props.pinnedDatastoreId, (id) => {
   if (id) model.value = id
 }, { immediate: true })
 
 watch(localSelection, (id) => {
-  if (!pinnedDatastoreId.value) model.value = id
+  if (!props.pinnedDatastoreId) model.value = id
 })
 </script>
diff --git a/components/Datasets/GeopfPanel.vue b/components/Datasets/GeopfPanel.vue
index 174438ed8..f5991e6b9 100644
--- a/components/Datasets/GeopfPanel.vue
+++ b/components/Datasets/GeopfPanel.vue
@@ -36,11 +36,12 @@
 </template>
 
 <script setup lang="ts">
-import { BannerAction, BrandedButton, toast, type DatasetV2 } from '@datagouv/components-next'
+import { BannerAction, BrandedButton, toast } from '@datagouv/components-next'
 import { RiLogoutBoxLine } from '@remixicon/vue'
 
 const props = defineProps<{
-  dataset: DatasetV2
+  // Id, not slug: /geopf/login/ only resolves by id.
+  datasetId: string
   connected: boolean | null
   reauthRequired?: boolean
 }>()
@@ -53,7 +54,7 @@ const { $api } = useNuxtApp()
 const { t } = useTranslation()
 const config = useRuntimeConfig()
 
-const geopfLoginUrl = computed(() => `${config.public.apiBase}/api/1/geopf/login/?dataset_id=${encodeURIComponent(props.dataset.id)}`)
+const geopfLoginUrl = computed(() => `${config.public.apiBase}/api/1/geopf/login/?dataset_id=${encodeURIComponent(props.datasetId)}`)
 
 const bannerType = computed(() => {
   if (props.reauthRequired) return 'danger'
diff --git a/components/Datasets/GeopfPullAction.vue b/components/Datasets/GeopfPullAction.vue
index dd2a11d9f..cd8c6cdf9 100644
--- a/components/Datasets/GeopfPullAction.vue
+++ b/components/Datasets/GeopfPullAction.vue
@@ -6,8 +6,8 @@
         size="xs"
         :icon="RiDownloadCloud2Line"
         :disabled="!!disabledReason"
-        :loading="pulling || pullState.status === 'pending'"
-        @click="pull"
+        :loading="pulling || pull.status === 'pending'"
+        @click="startPull"
       >
         {{ t('Récupérer les services') }}
       </BrandedButton>
@@ -18,32 +18,34 @@
     </component>
 
     <span
-      v-if="pullState.status === 'done' && pullState.lastSyncedAt"
+      v-if="pull.status === 'done' && pull.last_synced_at"
       class="text-xs text-gray-medium"
     >
-      {{ t('Dernière synchronisation : {date}', { date: formatDate(pullState.lastSyncedAt) }) }}
+      {{ t('Dernière synchronisation : {date}', { date: formatDate(pull.last_synced_at) }) }}
     </span>
     <span
-      v-else-if="pullState.status === 'error'"
+      v-else-if="pull.status === 'error'"
       class="text-xs text-new-error"
     >
-      {{ pullState.error }}
+      {{ pull.error }}
     </span>
   </div>
 </template>
 
 <script setup lang="ts">
-import { BrandedButton, Tooltip, useFormatDate, type DatasetV2 } from '@datagouv/components-next'
+import { BrandedButton, Tooltip, useFormatDate } from '@datagouv/components-next'
 import { RiDownloadCloud2Line } from '@remixicon/vue'
-import { getGeopfFicheUrl, getGeopfPullState, isGeopfReauthRequired } from '~/utils/geopf'
+import { isGeopfReauthRequired, type GeopfDatasetStatus } from '~/utils/geopf'
 
 const props = defineProps<{
-  dataset: DatasetV2
+  datasetId: string
   connected: boolean | null
+  pull: GeopfDatasetStatus['pull']
+  ficheUrl: string | null
+  refresh: () => Promise<void>
 }>()
 
 const emit = defineEmits<{
-  pulled: []
   reauthRequired: []
 }>()
 
@@ -51,22 +53,20 @@ const { $api } = useNuxtApp()
 const { t } = useTranslation()
 const { formatDate } = useFormatDate()
 
-const ficheUrl = computed(() => getGeopfFicheUrl(props.dataset))
-const pullState = computed(() => getGeopfPullState(props.dataset))
-
 const disabledReason = computed(() => {
   if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour récupérer les services.')
-  if (!ficheUrl.value) return t('Envoyez d\'abord un fichier au format GeoPackage (.gpkg) vers cartes.gouv.fr.')
+  if (!props.ficheUrl) return t('Envoyez d\'abord un fichier au format GeoPackage (.gpkg) vers cartes.gouv.fr.')
   return null
 })
 
 const pulling = ref(false)
 
-const pull = async () => {
+const startPull = async () => {
   pulling.value = true
   try {
-    await $api(`/api/1/geopf/pull-offerings/${props.dataset.id}/`, { method: 'POST' })
-    emit('pulled')
+    await $api(`/api/1/geopf/pull-offerings/${props.datasetId}/`, { method: 'POST' })
+    // Awaited: udata marks the dataset `pending` before enqueueing, so this returns the new status.
+    await props.refresh()
   }
   catch (error) {
     if (isGeopfReauthRequired(error)) {
diff --git a/components/Datasets/GeopfPushButton.vue b/components/Datasets/GeopfPushButton.vue
index a86d6a770..7964ce586 100644
--- a/components/Datasets/GeopfPushButton.vue
+++ b/components/Datasets/GeopfPushButton.vue
@@ -1,7 +1,7 @@
 <template>
   <component
     :is="disabledReason ? Tooltip : 'div'"
-    v-if="pushState.status === null"
+    v-if="push.status === null"
   >
     <BrandedButton
       color="secondary"
@@ -9,7 +9,7 @@
       :icon="RiUploadCloud2Line"
       :disabled="!!disabledReason"
       :loading="pushing"
-      @click="push"
+      @click="startPush"
     >
       {{ t('Envoyer vers cartes.gouv.fr') }}
     </BrandedButton>
@@ -20,28 +20,28 @@
   </component>
 
   <AdminBadge
-    v-else-if="pushState.status === 'pending'"
+    v-else-if="push.status === 'pending'"
     size="xs"
-    :type="getGeopfBadgeType(pushState.status)"
+    :type="getGeopfBadgeType(push.status)"
   >
     {{ t('Envoi en cours…') }}
   </AdminBadge>
 
   <div
-    v-else-if="pushState.status === 'done'"
+    v-else-if="push.status === 'done'"
     class="flex flex-col items-start"
   >
     <AdminBadge
       size="xs"
-      :type="getGeopfBadgeType(pushState.status)"
+      :type="getGeopfBadgeType(push.status)"
     >
       {{ t('Synchronisé') }}
     </AdminBadge>
     <span
-      v-if="pushState.lastSyncedAt"
+      v-if="push.last_synced_at"
       class="text-xs text-gray-medium"
     >
-      {{ formatDate(pushState.lastSyncedAt) }}
+      {{ formatDate(push.last_synced_at) }}
     </span>
   </div>
 
@@ -52,13 +52,13 @@
     <Tooltip>
       <AdminBadge
         size="xs"
-        :type="getGeopfBadgeType(pushState.status)"
+        :type="getGeopfBadgeType(push.status)"
       >
-        {{ pushState.status === 'timeout' ? t('Délai dépassé') : t("Échec de l'envoi") }}
+        {{ push.status === 'timeout' ? t('Délai dépassé') : t("Échec de l'envoi") }}
       </AdminBadge>
 
       <template #tooltip>
-        {{ pushState.error }}
+        {{ push.error }}
       </template>
     </Tooltip>
 
@@ -68,7 +68,7 @@
       :icon="RiRefreshLine"
       :disabled="!!disabledReason"
       :loading="pushing"
-      @click="push"
+      @click="startPush"
     >
       {{ t('Réessayer') }}
     </BrandedButton>
@@ -76,19 +76,19 @@
 </template>
 
 <script setup lang="ts">
-import { BrandedButton, Tooltip, useFormatDate, type Resource } from '@datagouv/components-next'
+import { BrandedButton, Tooltip, useFormatDate } from '@datagouv/components-next'
 import { RiRefreshLine, RiUploadCloud2Line } from '@remixicon/vue'
-import { getGeopfBadgeType, getGeopfPushState, isGeopfReauthRequired } from '~/utils/geopf'
+import { getGeopfBadgeType, isGeopfReauthRequired, type GeopfPushableResource } from '~/utils/geopf'
 
 const props = defineProps<{
-  resource: Resource
+  resource: GeopfPushableResource
   datasetId: string
   connected: boolean | null
   datastoreId: string | null
+  refresh: () => Promise<void>
 }>()
 
 const emit = defineEmits<{
-  pushed: []
   reauthRequired: []
 }>()
 
@@ -96,7 +96,7 @@ const { $api } = useNuxtApp()
 const { t } = useTranslation()
 const { formatDate } = useFormatDate()
 
-const pushState = computed(() => getGeopfPushState(props.resource))
+const push = computed(() => props.resource.push)
 
 const disabledReason = computed(() => {
   if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour envoyer ce fichier.')
@@ -106,14 +106,16 @@ const disabledReason = computed(() => {
 
 const pushing = ref(false)
 
-const push = async () => {
+const startPush = async () => {
   pushing.value = true
   try {
     await $api(`/api/1/geopf/push/${props.datasetId}/${props.resource.id}/`, {
       method: 'POST',
       body: { datastore_id: props.datastoreId },
     })
-    emit('pushed')
+    // Awaited: udata marks the resource `pending` before enqueueing, so this returns
+    // the new status and the button never re-enables in between.
+    await props.refresh()
   }
   catch (error) {
     if (isGeopfReauthRequired(error)) {
diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index 1cf922623..a89659a6f 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -3,7 +3,7 @@
     <template v-if="canEdit">
       <GeopfPanel
         v-if="dataset"
-        :dataset="dataset"
+        :dataset-id="dataset.id"
         :connected="isGeopfConnected"
         :reauth-required="reauthRequired"
         class="fr-mb-3w"
@@ -11,22 +11,21 @@
       />
 
       <GeopfDatastoreSelector
-        v-if="dataset"
         v-model="datastoreId"
-        :dataset="dataset"
+        :pinned-datastore-id="sync?.datastore_id ?? null"
         :connected="isGeopfConnected"
         class="fr-mb-3w"
       />
 
       <LoadingBlock
-        v-slot="{ data: loadedResourcesPage }"
+        v-slot="{ data: loadedSync }"
         :status
-        :data="resourcesPage"
+        :data="sync"
       >
         <h2 class="text-sm font-bold uppercase">
           {{ t('Fichiers à envoyer') }}
         </h2>
-        <AdminTable v-if="loadedResourcesPage && pushableResources.length">
+        <AdminTable v-if="loadedSync.pushable.length">
           <thead>
             <tr>
               <AdminTableTh scope="col">
@@ -42,7 +41,7 @@
           </thead>
           <tbody>
             <tr
-              v-for="resource in pushableResources"
+              v-for="resource in loadedSync.pushable"
               :key="resource.id"
             >
               <td>
@@ -57,12 +56,11 @@
               </td>
               <td>
                 <GeopfPushButton
-                  v-if="dataset"
                   :resource="resource"
-                  :dataset-id="dataset.id"
+                  :dataset-id="datasetId"
                   :connected="isGeopfConnected"
                   :datastore-id="datastoreId"
-                  @pushed="onGeopfPushed"
+                  :refresh="refreshSync"
                   @reauth-required="reauthRequired = true"
                 />
               </td>
@@ -81,14 +79,15 @@
             {{ t('Services récupérés depuis cartes.gouv.fr') }}
           </h2>
           <GeopfPullAction
-            v-if="dataset"
-            :dataset="dataset"
+            :dataset-id="datasetId"
             :connected="isGeopfConnected"
-            @pulled="onGeopfPulled"
+            :pull="loadedSync.pull"
+            :fiche-url="loadedSync.fiche_url"
+            :refresh="refreshSync"
             @reauth-required="reauthRequired = true"
           />
         </div>
-        <AdminTable v-if="loadedResourcesPage && syncedResources.length">
+        <AdminTable v-if="loadedSync.offerings.length">
           <thead>
             <tr>
               <AdminTableTh scope="col">
@@ -104,7 +103,7 @@
           </thead>
           <tbody>
             <tr
-              v-for="resource in syncedResources"
+              v-for="resource in loadedSync.offerings"
               :key="resource.id"
             >
               <td>
@@ -118,7 +117,7 @@
                 {{ resource.format }}
               </td>
               <td>
-                {{ formatDate(getGeopfOfferingLastSyncedAt(resource)) }}
+                {{ formatDate(resource.last_synced_at) }}
               </td>
             </tr>
           </tbody>
@@ -131,10 +130,10 @@
         </p>
 
         <BrandedButton
-          v-if="ficheUrl"
+          v-if="loadedSync.fiche_url"
           color="secondary"
           size="xs"
-          :href="ficheUrl"
+          :href="loadedSync.fiche_url"
           new-tab
           class="mt-3"
         >
@@ -152,31 +151,37 @@
 </template>
 
 <script setup lang="ts">
-import { BrandedButton, LoadingBlock, useFormatDate, type DatasetV2, type Resource } from '@datagouv/components-next'
+import { BrandedButton, LoadingBlock, useFormatDate, type DatasetV2 } from '@datagouv/components-next'
 import GeopfDatastoreSelector from './GeopfDatastoreSelector.vue'
 import GeopfPanel from './GeopfPanel.vue'
 import GeopfPullAction from './GeopfPullAction.vue'
 import GeopfPushButton from './GeopfPushButton.vue'
 import AdminTable from '../AdminTable/Table/AdminTable.vue'
 import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
-import type { PaginatedArray } from '~/types/types'
-import { GEOPF_LIST_PAGE_SIZE, getGeopfFicheUrl, getGeopfOfferingLastSyncedAt, getGeopfPullState, getGeopfPushState, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'
 
 const route = useRoute()
-const { $api } = useNuxtApp()
 const { t } = useTranslation()
 const { formatDate } = useFormatDate()
 const config = useRuntimeConfig()
 
-const datasetUrl = computed(() => `/api/2/datasets/${route.params.id}/`)
-const { data: dataset, status, refresh: refreshDataset } = await useAPI<DatasetV2>(datasetUrl, {
+const datasetId = computed(() => String(route.params.id))
+
+// Only for the permission check; dedupes with the parent admin layout's identical call.
+const datasetUrl = computed(() => `/api/2/datasets/${datasetId.value}/`)
+const { data: dataset } = await useAPI<DatasetV2>(datasetUrl, {
   redirectOn404: true,
   headers: {
     'X-Get-Datasets-Full-Objects': 'True',
   },
 })
 const canEdit = computed(() => dataset.value?.permissions.edit_resources ?? false)
-const ficheUrl = computed(() => dataset.value ? getGeopfFicheUrl(dataset.value) : null)
+
+// Everything both tables render, already filtered and projected by udata.
+const { data: sync, status, refresh: refreshSync } = await useAPI<GeopfDatasetStatus>(
+  computed(() => geopfDatasetStatusUrl(datasetId.value)),
+  { key: geopfDatasetStatusKey(datasetId.value) },
+)
 
 const { data: geopfConnected } = config.public.geopfEnabled
   ? await useAPI<{ connected: boolean, expires_at: string | null }>('/api/1/geopf/status/')
@@ -185,28 +190,11 @@ const isGeopfConnected = computed(() => geopfConnected.value?.connected ?? null)
 const reauthRequired = ref(false)
 const datastoreId = ref<string | null>(null)
 
-const resourcesPage = ref<PaginatedArray<Resource> | null>(null)
-const refreshResources = async () => {
-  if (!dataset.value) return
-  resourcesPage.value = await $api<PaginatedArray<Resource>>(dataset.value.resources.href, { query: { page_size: GEOPF_LIST_PAGE_SIZE } })
-}
-watchEffect(async () => await refreshResources())
-
-const pushableResources = computed(() => (resourcesPage.value?.data ?? []).filter(isGeopfPushable))
-const syncedResources = computed(() => (resourcesPage.value?.data ?? []).filter(isGeopfOffering))
-
 const geopfPending = computed(() => {
-  const pushPending = pushableResources.value.some(r => getGeopfPushState(r).status === 'pending')
-  const pullPending = dataset.value ? getGeopfPullState(dataset.value).status === 'pending' : false
-  return pushPending || pullPending
-})
-useGeopfPolling(geopfPending, async () => {
-  await Promise.all([refreshResources(), refreshDataset()])
+  if (!sync.value) return false
+  return sync.value.pushable.some(r => r.push.status === 'pending') || sync.value.pull.status === 'pending'
 })
+useGeopfPolling(geopfPending, refreshSync)
 
-const onGeopfPulled = async () => await Promise.all([refreshDataset(), refreshResources()])
-// A push can also write dataset-level extras (fiche-url, pinned datastore-id) on its
-// first success, so refresh both here too — not just the resource that was pushed.
-const onGeopfPushed = async () => await Promise.all([refreshDataset(), refreshResources()])
 const onGeopfDisconnected = () => reloadNuxtApp({ path: route.fullPath })
 </script>
diff --git a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
index 4272e1dbd..940c329ed 100644
--- a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
+++ b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
@@ -373,10 +373,10 @@ const hasPmtiles = computed(() => {
   return props.resource.extras['analysis:parsing:pmtiles_url'] || props.resource.format === 'pmtiles'
 })
 
-// A resource successfully pushed to, or pulled back from, Géoplateforme shouldn't be
-// edited locally: doing so would silently diverge from what's published on cartes.gouv.fr.
+// Mirrors `isGeopfSynced` in cdata's utils/geopf.ts.
 const isGeopfSynced = computed(() => {
-  return props.resource.extras['geopf:push:status'] === 'done' || typeof props.resource.extras['geopf:offering:id'] === 'string'
+  const status = props.resource.extras['geopf:push:status']
+  return status === 'done' || status === 'pending' || typeof props.resource.extras['geopf:offering:id'] === 'string'
 })
 
 const hasDatafairPreview = computed(() => {
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 7d6a29212..917361232 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -136,7 +136,7 @@
 
 <script setup lang="ts">
 import { BrandedButton, DatasetQualityTooltipContent, QualityScore, summarize, useFormatDate, AvatarWithName, Tooltip, getActivityTranslation } from '@datagouv/components-next'
-import type { Activity, DatasetV2WithFullObject, Resource } from '@datagouv/components-next'
+import type { Activity, DatasetV2WithFullObject } from '@datagouv/components-next'
 import { RiBarChartBoxLine, RiCalendarLine, RiDownloadLine, RiEyeLine, RiLineChartLine, RiPriceTag3Line, RiStarLine } from '@remixicon/vue'
 import DatasetBadge from '~/components/AdminBadge/DatasetBadge.vue'
 import AdminBreadcrumb from '~/components/Breadcrumbs/AdminBreadcrumb.vue'
@@ -144,7 +144,7 @@ import BreadcrumbItem from '~/components/Breadcrumbs/BreadcrumbItem.vue'
 import TabLinks from '~/components/TabLinks.vue'
 import { geopfEligibilityRefreshKey } from '~/components/Datasets/geopfEligibilityRefreshKey'
 import type { PaginatedArray } from '~/types/types'
-import { GEOPF_LIST_PAGE_SIZE, isGeopfOffering, isGeopfPushable } from '~/utils/geopf'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'
 import type { RouteLocationNormalizedLoaded } from 'vue-router'
 
 definePageMeta({
@@ -171,16 +171,19 @@ const { data: activities } = await useAPI<PaginatedArray<Activity>>('/api/1/acti
   },
 })
 
-// Fetched only to decide whether the geopf tab is worth showing: a dataset with no
-// gpkg resource and nothing pulled back from cartes.gouv.fr has nothing to do there.
-const { data: geopfResources, refresh: refreshGeopfResources } = config.public.geopfEnabled
-  ? await useAPI<PaginatedArray<Resource>>(computed(() => dataset.value?.resources.href ?? ''), { query: { page_size: GEOPF_LIST_PAGE_SIZE } })
+// Drives the geopf tab's visibility. Shares its useAsyncData key with GeopfSyncPage.
+const canFetchGeopfStatus = Boolean(config.public.geopfEnabled && dataset.value?.permissions.edit_resources)
+const { data: geopfStatus, refresh: refreshGeopfStatus } = canFetchGeopfStatus
+  ? await useAPI<GeopfDatasetStatus>(
+      computed(() => geopfDatasetStatusUrl(String(route.params.id))),
+      { key: geopfDatasetStatusKey(String(route.params.id)) },
+    )
   : { data: ref(null), refresh: async () => {} }
-const hasEligibleGeopfResource = computed(() => (geopfResources.value?.data ?? []).some(r => isGeopfPushable(r) || isGeopfOffering(r)))
+const hasEligibleGeopfResource = computed(() => Boolean(geopfStatus.value && (geopfStatus.value.pushable.length || geopfStatus.value.offerings.length)))
 
 // The Files tab (a NuxtPage descendant) calls this after any resource change, so
 // a newly-uploaded gpkg makes the tab appear without a full page reload.
-provide(geopfEligibilityRefreshKey, () => refreshGeopfResources())
+provide(geopfEligibilityRefreshKey, () => refreshGeopfStatus())
 
 // Stable reference: NuxtPage compares page-key by reference, so an inline function here
 // would re-trigger the loading indicator whenever `dataset` changes and this re-renders.
diff --git a/pages/admin/datasets/[id]/geopf.vue b/pages/admin/datasets/[id]/geopf.vue
index 08a8ac1c5..6d3373c83 100644
--- a/pages/admin/datasets/[id]/geopf.vue
+++ b/pages/admin/datasets/[id]/geopf.vue
@@ -6,6 +6,7 @@
 import type { DatasetV2 } from '@datagouv/components-next'
 import GeopfSyncPage from '~/components/Datasets/GeopfSyncPage.vue'
 
+// Passed by the parent NuxtPage to every tab; unused here.
 defineProps<{
   dataset: DatasetV2
 }>()
diff --git a/utils/geopf.ts b/utils/geopf.ts
index ea1b641e5..2eac7c703 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -1,88 +1,60 @@
-import type { DatasetV2, Resource } from '@datagouv/components-next'
+import type { Resource } from '@datagouv/components-next'
 import type { AdminBadgeType } from '~/types/types'
 
-// Only gpkg is processed by the udata geopf plugin today (GEOPF_PUSHABLE_FORMATS),
-// and it isn't exposed by any API endpoint, so this is a known, documented coupling
-// with the backend config: see udata/docs/geopf.md.
-export const GEOPF_PUSHABLE_FORMAT = 'gpkg'
-
 export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
 export type GeopfPullStatus = 'pending' | 'done' | 'error'
 
-// Large enough to cover a typical dataset's gpkg/offering resources in one request,
-// since only this small subset (eligible resources) is relevant to geopf sync.
-export const GEOPF_LIST_PAGE_SIZE = 100
-
-export function isGeopfPushable(resource: Resource): boolean {
-  return resource.format?.toLowerCase() === GEOPF_PUSHABLE_FORMAT && !isGeopfOffering(resource)
-}
-
-export function isGeopfOffering(resource: Resource): boolean {
-  return typeof resource.extras['geopf:offering:id'] === 'string'
-}
-
-export function getGeopfOfferingLastSyncedAt(resource: Resource): string | null {
-  return (resource.extras['geopf:offering:last-synced-at'] as string | undefined) ?? null
+// Shape of `GET /api/1/geopf/status/<dataset_id>/` (see udata/docs/geopf.md).
+// A null `status` means "never run".
+export type GeopfPushableResource = {
+  id: string
+  title: string
+  format: string | null
+  url: string | null
+  push: {
+    status: GeopfPushStatus | null
+    last_synced_at: string | null
+    error: string | null
+    task_id: string | null
+    stored_data_id: string | null
+  }
 }
 
-// A resource tied into the Géoplateforme sync (successfully pushed, or pulled back
-// as an offering) shouldn't be edited/replaced locally: doing so would silently
-// diverge from what's published on cartes.gouv.fr.
-export function isGeopfSynced(resource: Resource): boolean {
-  return resource.extras['geopf:push:status'] === 'done' || isGeopfOffering(resource)
+export type GeopfOfferingResource = {
+  id: string
+  title: string
+  format: string | null
+  url: string | null
+  offering_id: string
+  last_synced_at: string | null
 }
 
-export type GeopfPushState
-  = | { status: null }
-    | { status: 'pending' }
-    | { status: 'done', lastSyncedAt: string | null }
-    | { status: 'error' | 'timeout', error: string | null }
-
-export function getGeopfPushState(resource: Resource): GeopfPushState {
-  const status = resource.extras['geopf:push:status'] as GeopfPushStatus | undefined
-
-  if (status === 'done') {
-    return { status: 'done', lastSyncedAt: (resource.extras['geopf:push:last-synced-at'] as string | undefined) ?? null }
-  }
-  if (status === 'error' || status === 'timeout') {
-    return { status, error: (resource.extras['geopf:push:error'] as string | undefined) ?? null }
-  }
-  if (status === 'pending') {
-    return { status: 'pending' }
+export type GeopfDatasetStatus = {
+  datastore_id: string | null
+  fiche_url: string | null
+  pull: {
+    status: GeopfPullStatus | null
+    last_synced_at: string | null
+    error: string | null
+    task_id: string | null
   }
-  return { status: null }
+  pushable: Array<GeopfPushableResource>
+  offerings: Array<GeopfOfferingResource>
 }
 
-export type GeopfPullState
-  = | { status: null }
-    | { status: 'pending' }
-    | { status: 'done', lastSyncedAt: string | null }
-    | { status: 'error', error: string | null }
-
-export function getGeopfPullState(dataset: DatasetV2): GeopfPullState {
-  const status = dataset.extras['geopf:pull:status'] as GeopfPullStatus | undefined
-
-  if (status === 'done') {
-    return { status: 'done', lastSyncedAt: (dataset.extras['geopf:pull:last-synced-at'] as string | undefined) ?? null }
-  }
-  if (status === 'error') {
-    return { status: 'error', error: (dataset.extras['geopf:pull:error'] as string | undefined) ?? null }
-  }
-  if (status === 'pending') {
-    return { status: 'pending' }
-  }
-  return { status: null }
+export function geopfDatasetStatusUrl(datasetId: string): string {
+  return `/api/1/geopf/status/${datasetId}/`
 }
 
-export function getGeopfFicheUrl(dataset: DatasetV2): string | null {
-  return (dataset.extras['geopf:push:fiche-url'] as string | undefined) ?? null
+// Shared by the admin dataset layout and the sync page, so both read one useAsyncData entry.
+export function geopfDatasetStatusKey(datasetId: string): string {
+  return `geopf-status-${datasetId}`
 }
 
-// A dataset lives in exactly one entrepôt: this is pinned in dataset extras on
-// the first *successful* push and reused as-is by every later push (see
-// udata/docs/geopf.md). Not editable once set.
-export function getGeopfDatastoreId(dataset: DatasetV2): string | null {
-  return (dataset.extras['geopf:push:datastore-id'] as string | undefined) ?? null
+// Resources whose local edition would diverge from what cartes.gouv.fr publishes.
+export function isGeopfSynced(resource: Resource): boolean {
+  const status = resource.extras['geopf:push:status']
+  return status === 'done' || status === 'pending' || typeof resource.extras['geopf:offering:id'] === 'string'
 }
 
 // Raw pass-through of geopf's own API shape (GET /datastores).
@@ -91,9 +63,7 @@ export type GeopfDatastore = {
   name: string
 }
 
-// 424 means "not connected to Géoplateforme" for both push and pull (see udata/docs/geopf.md);
-// the global $api error handler swallows it silently, so callers check it themselves
-// to prompt reconnection instead of failing silently.
+// Push and pull answer 424 when not connected; the global $api handler swallows it.
 export function isGeopfReauthRequired(error: unknown): boolean {
   if (!error || typeof error !== 'object' || !('response' in error)) return false
   const response = (error as { response?: { status?: number } }).response

From 30156d2b90962fb273980a3f66e1c5c1e539d1be Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 16:11:35 +0200
Subject: [PATCH 06/24] feature flag guard

---
 components/Datasets/GeopfSyncPage.vue | 5 +----
 pages/admin/datasets/[id]/geopf.vue   | 9 +++++++--
 2 files changed, 8 insertions(+), 6 deletions(-)

diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index a89659a6f..a76d37e5d 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -163,7 +163,6 @@ import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus }
 const route = useRoute()
 const { t } = useTranslation()
 const { formatDate } = useFormatDate()
-const config = useRuntimeConfig()
 
 const datasetId = computed(() => String(route.params.id))
 
@@ -183,9 +182,7 @@ const { data: sync, status, refresh: refreshSync } = await useAPI<GeopfDatasetSt
   { key: geopfDatasetStatusKey(datasetId.value) },
 )
 
-const { data: geopfConnected } = config.public.geopfEnabled
-  ? await useAPI<{ connected: boolean, expires_at: string | null }>('/api/1/geopf/status/')
-  : { data: ref(null) }
+const { data: geopfConnected } = await useAPI<{ connected: boolean, expires_at: string | null }>('/api/1/geopf/status/')
 const isGeopfConnected = computed(() => geopfConnected.value?.connected ?? null)
 const reauthRequired = ref(false)
 const datastoreId = ref<string | null>(null)
diff --git a/pages/admin/datasets/[id]/geopf.vue b/pages/admin/datasets/[id]/geopf.vue
index 6d3373c83..ee4e2c4c1 100644
--- a/pages/admin/datasets/[id]/geopf.vue
+++ b/pages/admin/datasets/[id]/geopf.vue
@@ -1,13 +1,18 @@
 <template>
-  <GeopfSyncPage />
+  <GeopfSyncPage v-if="config.public.geopfEnabled" />
 </template>
 
 <script setup lang="ts">
 import type { DatasetV2 } from '@datagouv/components-next'
 import GeopfSyncPage from '~/components/Datasets/GeopfSyncPage.vue'
 
-// Passed by the parent NuxtPage to every tab; unused here.
 defineProps<{
   dataset: DatasetV2
 }>()
+
+const config = useRuntimeConfig()
+
+if (!config.public.geopfEnabled) {
+  showError({ statusCode: 404, statusMessage: 'Page Not Found' })
+}
 </script>

From 4faed50556bb4b3b1762334d8275b63c6b62cdd8 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 16:18:04 +0200
Subject: [PATCH 07/24] simpler polling

---
 composables/useGeopfPolling.ts | 34 ++++------------------------------
 1 file changed, 4 insertions(+), 30 deletions(-)

diff --git a/composables/useGeopfPolling.ts b/composables/useGeopfPolling.ts
index 8a3bedfa8..2e8f121d3 100644
--- a/composables/useGeopfPolling.ts
+++ b/composables/useGeopfPolling.ts
@@ -2,37 +2,11 @@ import { useIntervalFn } from '@vueuse/core'
 import type { ComputedRef } from 'vue'
 
 const POLL_INTERVAL_MS = 8000
-// Push can span roughly two server-side poll timeouts (see udata/docs/geopf.md);
-// this is a client-side ceiling, not a failure signal — the extras stay the
-// source of truth, a manual reload still picks up the eventual terminal status.
-const MAX_POLL_DURATION_MS = 5 * 60 * 1000
 
+// Polls for as long as a push or pull is pending. `useIntervalFn` pauses itself on
+// scope dispose.
 export function useGeopfPolling(pending: ComputedRef<boolean>, tick: () => Promise<void>) {
-  const timedOut = ref(false)
-  let elapsed = 0
+  const { pause, resume } = useIntervalFn(tick, POLL_INTERVAL_MS, { immediate: false })
 
-  const { pause, resume, isActive } = useIntervalFn(async () => {
-    elapsed += POLL_INTERVAL_MS
-    if (elapsed >= MAX_POLL_DURATION_MS) {
-      timedOut.value = true
-      pause()
-      return
-    }
-    await tick()
-  }, POLL_INTERVAL_MS, { immediate: false })
-
-  watch(pending, (isPending) => {
-    if (isPending) {
-      elapsed = 0
-      timedOut.value = false
-      resume()
-    }
-    else {
-      pause()
-    }
-  }, { immediate: true })
-
-  onUnmounted(() => pause())
-
-  return { isPolling: isActive, timedOut }
+  watch(pending, isPending => isPending ? resume() : pause(), { immediate: true })
 }

From 9e14f6ab361266a38b69ec51d0879199d03c126f Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 16:32:19 +0200
Subject: [PATCH 08/24] scope 424 intercept

---
 plugins/api.ts | 7 +++----
 1 file changed, 3 insertions(+), 4 deletions(-)

diff --git a/plugins/api.ts b/plugins/api.ts
index 391343cff..4a89381fc 100644
--- a/plugins/api.ts
+++ b/plugins/api.ts
@@ -36,7 +36,7 @@ export default defineNuxtPlugin({
             options.query['lang'] = locale
           }
         },
-        async onResponseError({ response, options }) {
+        async onResponseError({ request, response, options }) {
           if (response.status === 404) {
             if (apiOptions.redirectOn404) {
               await nuxtApp.runWithContext(() => showError({ statusCode: 404, statusMessage: 'Page Not Found' }))
@@ -60,9 +60,8 @@ export default defineNuxtPlugin({
             }
           }
 
-          if (response.status === 424) {
-            // Used by geopf push/pull to mean "not connected": callers handle this
-            // themselves (prompt to reconnect) instead of a generic toast.
+          if (response.status === 424 && typeof request === 'string' && request.includes('/geopf/')) {
+            // Means "not connected": callers handle this themselves (prompt to reconnect).
             return
           }
 

From abcf5440128920980b993e13f20a45b97f62a12d Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 16:53:19 +0200
Subject: [PATCH 09/24] factorize isGeopfSynced

---
 .../components/ResourceAccordion/ResourceAccordion.vue | 10 ++--------
 datagouv-components/src/functions/resources.ts         |  6 ++++++
 utils/geopf.ts                                         |  9 ++-------
 3 files changed, 10 insertions(+), 15 deletions(-)

diff --git a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
index 940c329ed..05e659d97 100644
--- a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
+++ b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
@@ -163,7 +163,7 @@
             :dataset-id="dataset.id"
             :resource-id="resource.id"
             :is-community-resource="isCommunityResource"
-            :disabled="isGeopfSynced"
+            :disabled="isGeopfSynced(resource)"
             size="xs"
           />
         </p>
@@ -317,7 +317,7 @@ import { trackEvent } from '../../functions/matomo'
 import CopyButton from '../CopyButton.vue'
 import { useComponentsConfig } from '../../config'
 import { getOwnerName } from '../../functions/owned'
-import { getResourceFormatIcon, getResourceTitleId, detectOgcService, getResourceExternalUrl, getResourceFilesize, isImagePreviewFormat } from '../../functions/resources'
+import { getResourceFormatIcon, getResourceTitleId, detectOgcService, getResourceExternalUrl, getResourceFilesize, isGeopfSynced, isImagePreviewFormat } from '../../functions/resources'
 import BrandedButton from '../BrandedButton.vue'
 import { useTranslation } from '../../composables/useTranslation'
 import { useHasTabularData } from '../../composables/useHasTabularData'
@@ -373,12 +373,6 @@ const hasPmtiles = computed(() => {
   return props.resource.extras['analysis:parsing:pmtiles_url'] || props.resource.format === 'pmtiles'
 })
 
-// Mirrors `isGeopfSynced` in cdata's utils/geopf.ts.
-const isGeopfSynced = computed(() => {
-  const status = props.resource.extras['geopf:push:status']
-  return status === 'done' || status === 'pending' || typeof props.resource.extras['geopf:offering:id'] === 'string'
-})
-
 const hasDatafairPreview = computed(() => {
   // Checks if there are the corresponding extras for a datafair preview.
   // Limited only to datasets published by certified organizations since it will load an iframe.
diff --git a/datagouv-components/src/functions/resources.ts b/datagouv-components/src/functions/resources.ts
index 3e0b17c1e..f9abe9aba 100644
--- a/datagouv-components/src/functions/resources.ts
+++ b/datagouv-components/src/functions/resources.ts
@@ -179,6 +179,12 @@ export function getResourceExternalUrl(dataset: Dataset | DatasetV2 | Omit<Datas
   return `${dataset.page}${isCommunityResource(resource) ? '/community-resources' : ''}?resource_id=${resource.id}`
 }
 
+// Resources whose local edition would diverge from what cartes.gouv.fr publishes.
+export function isGeopfSynced(resource: Resource | CommunityResource): boolean {
+  const status = resource.extras['geopf:push:status']
+  return status === 'done' || status === 'pending' || typeof resource.extras['geopf:offering:id'] === 'string'
+}
+
 export function getResourceFilesize(resource: Resource): null | number {
   if (resource.filesize) return resource.filesize
   if ('analysis:content-length' in resource.extras) return resource.extras['analysis:content-length'] as number
diff --git a/utils/geopf.ts b/utils/geopf.ts
index 2eac7c703..dd7ad641f 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -1,6 +1,7 @@
-import type { Resource } from '@datagouv/components-next'
 import type { AdminBadgeType } from '~/types/types'
 
+export { isGeopfSynced } from '@datagouv/components-next'
+
 export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
 export type GeopfPullStatus = 'pending' | 'done' | 'error'
 
@@ -51,12 +52,6 @@ export function geopfDatasetStatusKey(datasetId: string): string {
   return `geopf-status-${datasetId}`
 }
 
-// Resources whose local edition would diverge from what cartes.gouv.fr publishes.
-export function isGeopfSynced(resource: Resource): boolean {
-  const status = resource.extras['geopf:push:status']
-  return status === 'done' || status === 'pending' || typeof resource.extras['geopf:offering:id'] === 'string'
-}
-
 // Raw pass-through of geopf's own API shape (GET /datastores).
 export type GeopfDatastore = {
   datastore_id: string

From 3fae7284831d4a1029bdceb3d958e4178faaa1d4 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 16:56:12 +0200
Subject: [PATCH 10/24] catch

---
 components/Datasets/GeopfPanel.vue | 3 +++
 1 file changed, 3 insertions(+)

diff --git a/components/Datasets/GeopfPanel.vue b/components/Datasets/GeopfPanel.vue
index f5991e6b9..100020e04 100644
--- a/components/Datasets/GeopfPanel.vue
+++ b/components/Datasets/GeopfPanel.vue
@@ -74,6 +74,9 @@ const disconnect = async () => {
     toast.success(t('Vous êtes déconnecté de cartes.gouv.fr.'))
     emit('disconnected')
   }
+  catch {
+    // plugins/api.ts already toasted the error.
+  }
   finally {
     disconnecting.value = false
   }

From 645cdd14a2c3fb2829ddcfe385f5e59cdefea679 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Wed, 19 Aug 2026 18:08:31 +0200
Subject: [PATCH 11/24] more unit tests

---
 .../datagouv-components/resources.spec.ts     | 26 ++++++++++++++++++-
 1 file changed, 25 insertions(+), 1 deletion(-)

diff --git a/tests-unit/datagouv-components/resources.spec.ts b/tests-unit/datagouv-components/resources.spec.ts
index b718cc4a2..07ad5b82f 100644
--- a/tests-unit/datagouv-components/resources.spec.ts
+++ b/tests-unit/datagouv-components/resources.spec.ts
@@ -1,7 +1,7 @@
 import { createApp } from 'vue'
 import { describe, expect, it } from 'vitest'
 import { configKey, type ResolvedPluginConfig } from '~/datagouv-components/src/config'
-import { detectOgcService, getResourceCorsStatus, isCommunityResource } from '~/datagouv-components/src/functions/resources'
+import { detectOgcService, getResourceCorsStatus, isCommunityResource, isGeopfSynced } from '~/datagouv-components/src/functions/resources'
 import type { CommunityResource, Resource } from '~/datagouv-components/src/types/resources'
 
 // `useComponentsConfig` relies on Vue's inject: run the function inside an app
@@ -70,3 +70,27 @@ describe('isCommunityResource', () => {
     expect(isCommunityResource({ id: 'res-1' } as unknown as Resource)).toBe(false)
   })
 })
+
+describe('isGeopfSynced', () => {
+  it('is false without any geopf extras', () => {
+    expect(isGeopfSynced({ extras: {} } as Resource)).toBe(false)
+  })
+
+  it('is true while a push is pending, or once it succeeded', () => {
+    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'pending' } } as unknown as Resource)).toBe(true)
+    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'done' } } as unknown as Resource)).toBe(true)
+  })
+
+  it('is false for a failed or timed out push', () => {
+    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'error' } } as unknown as Resource)).toBe(false)
+    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'timeout' } } as unknown as Resource)).toBe(false)
+  })
+
+  it('is true for a resource pulled back as an offering', () => {
+    expect(isGeopfSynced({ extras: { 'geopf:offering:id': 'offering-1' } } as unknown as Resource)).toBe(true)
+  })
+
+  it('ignores a non-string offering id', () => {
+    expect(isGeopfSynced({ extras: { 'geopf:offering:id': 42 } } as unknown as Resource)).toBe(false)
+  })
+})

From 947e20f83a1961eadacd325c2c3091da8e6df374 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 09:26:14 +0200
Subject: [PATCH 12/24] =?UTF-8?q?geopfStatus=20=E2=86=92=20geopfDatasetSta?=
 =?UTF-8?q?tus?=
MIME-Version: 1.0
Content-Type: text/plain; charset=UTF-8
Content-Transfer-Encoding: 8bit

---
 components/Datasets/GeopfSyncPage.vue | 34 +++++++++++++--------------
 pages/admin/datasets/[id].vue         |  6 ++---
 2 files changed, 20 insertions(+), 20 deletions(-)

diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index a76d37e5d..f95d3ae27 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -12,20 +12,20 @@
 
       <GeopfDatastoreSelector
         v-model="datastoreId"
-        :pinned-datastore-id="sync?.datastore_id ?? null"
+        :pinned-datastore-id="geopfDatasetStatus?.datastore_id ?? null"
         :connected="isGeopfConnected"
         class="fr-mb-3w"
       />
 
       <LoadingBlock
-        v-slot="{ data: loadedSync }"
+        v-slot="{ data: loadedGeopfDatasetStatus }"
         :status
-        :data="sync"
+        :data="geopfDatasetStatus"
       >
         <h2 class="text-sm font-bold uppercase">
           {{ t('Fichiers à envoyer') }}
         </h2>
-        <AdminTable v-if="loadedSync.pushable.length">
+        <AdminTable v-if="loadedGeopfDatasetStatus.pushable.length">
           <thead>
             <tr>
               <AdminTableTh scope="col">
@@ -41,7 +41,7 @@
           </thead>
           <tbody>
             <tr
-              v-for="resource in loadedSync.pushable"
+              v-for="resource in loadedGeopfDatasetStatus.pushable"
               :key="resource.id"
             >
               <td>
@@ -60,7 +60,7 @@
                   :dataset-id="datasetId"
                   :connected="isGeopfConnected"
                   :datastore-id="datastoreId"
-                  :refresh="refreshSync"
+                  :refresh="refreshGeopfDatasetStatus"
                   @reauth-required="reauthRequired = true"
                 />
               </td>
@@ -81,13 +81,13 @@
           <GeopfPullAction
             :dataset-id="datasetId"
             :connected="isGeopfConnected"
-            :pull="loadedSync.pull"
-            :fiche-url="loadedSync.fiche_url"
-            :refresh="refreshSync"
+            :pull="loadedGeopfDatasetStatus.pull"
+            :fiche-url="loadedGeopfDatasetStatus.fiche_url"
+            :refresh="refreshGeopfDatasetStatus"
             @reauth-required="reauthRequired = true"
           />
         </div>
-        <AdminTable v-if="loadedSync.offerings.length">
+        <AdminTable v-if="loadedGeopfDatasetStatus.offerings.length">
           <thead>
             <tr>
               <AdminTableTh scope="col">
@@ -103,7 +103,7 @@
           </thead>
           <tbody>
             <tr
-              v-for="resource in loadedSync.offerings"
+              v-for="resource in loadedGeopfDatasetStatus.offerings"
               :key="resource.id"
             >
               <td>
@@ -130,10 +130,10 @@
         </p>
 
         <BrandedButton
-          v-if="loadedSync.fiche_url"
+          v-if="loadedGeopfDatasetStatus.fiche_url"
           color="secondary"
           size="xs"
-          :href="loadedSync.fiche_url"
+          :href="loadedGeopfDatasetStatus.fiche_url"
           new-tab
           class="mt-3"
         >
@@ -177,7 +177,7 @@ const { data: dataset } = await useAPI<DatasetV2>(datasetUrl, {
 const canEdit = computed(() => dataset.value?.permissions.edit_resources ?? false)
 
 // Everything both tables render, already filtered and projected by udata.
-const { data: sync, status, refresh: refreshSync } = await useAPI<GeopfDatasetStatus>(
+const { data: geopfDatasetStatus, status, refresh: refreshGeopfDatasetStatus } = await useAPI<GeopfDatasetStatus>(
   computed(() => geopfDatasetStatusUrl(datasetId.value)),
   { key: geopfDatasetStatusKey(datasetId.value) },
 )
@@ -188,10 +188,10 @@ const reauthRequired = ref(false)
 const datastoreId = ref<string | null>(null)
 
 const geopfPending = computed(() => {
-  if (!sync.value) return false
-  return sync.value.pushable.some(r => r.push.status === 'pending') || sync.value.pull.status === 'pending'
+  if (!geopfDatasetStatus.value) return false
+  return geopfDatasetStatus.value.pushable.some(r => r.push.status === 'pending') || geopfDatasetStatus.value.pull.status === 'pending'
 })
-useGeopfPolling(geopfPending, refreshSync)
+useGeopfPolling(geopfPending, refreshGeopfDatasetStatus)
 
 const onGeopfDisconnected = () => reloadNuxtApp({ path: route.fullPath })
 </script>
diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 917361232..3f70ddf33 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -173,17 +173,17 @@ const { data: activities } = await useAPI<PaginatedArray<Activity>>('/api/1/acti
 
 // Drives the geopf tab's visibility. Shares its useAsyncData key with GeopfSyncPage.
 const canFetchGeopfStatus = Boolean(config.public.geopfEnabled && dataset.value?.permissions.edit_resources)
-const { data: geopfStatus, refresh: refreshGeopfStatus } = canFetchGeopfStatus
+const { data: geopfDatasetStatus, refresh: refreshGeopfDatasetStatus } = canFetchGeopfStatus
   ? await useAPI<GeopfDatasetStatus>(
       computed(() => geopfDatasetStatusUrl(String(route.params.id))),
       { key: geopfDatasetStatusKey(String(route.params.id)) },
     )
   : { data: ref(null), refresh: async () => {} }
-const hasEligibleGeopfResource = computed(() => Boolean(geopfStatus.value && (geopfStatus.value.pushable.length || geopfStatus.value.offerings.length)))
+const hasEligibleGeopfResource = computed(() => Boolean(geopfDatasetStatus.value && (geopfDatasetStatus.value.pushable.length || geopfDatasetStatus.value.offerings.length)))
 
 // The Files tab (a NuxtPage descendant) calls this after any resource change, so
 // a newly-uploaded gpkg makes the tab appear without a full page reload.
-provide(geopfEligibilityRefreshKey, () => refreshGeopfStatus())
+provide(geopfEligibilityRefreshKey, () => refreshGeopfDatasetStatus())
 
 // Stable reference: NuxtPage compares page-key by reference, so an inline function here
 // would re-trigger the loading indicator whenever `dataset` changes and this re-renders.

From 6c4c53189b0e758433dcb9d322a915d2428312a9 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 09:28:49 +0200
Subject: [PATCH 13/24] nitpick

---
 pages/admin/datasets/[id].vue | 6 +++---
 1 file changed, 3 insertions(+), 3 deletions(-)

diff --git a/pages/admin/datasets/[id].vue b/pages/admin/datasets/[id].vue
index 3f70ddf33..7634b8e7b 100644
--- a/pages/admin/datasets/[id].vue
+++ b/pages/admin/datasets/[id].vue
@@ -181,11 +181,11 @@ const { data: geopfDatasetStatus, refresh: refreshGeopfDatasetStatus } = canFetc
   : { data: ref(null), refresh: async () => {} }
 const hasEligibleGeopfResource = computed(() => Boolean(geopfDatasetStatus.value && (geopfDatasetStatus.value.pushable.length || geopfDatasetStatus.value.offerings.length)))
 
-// The Files tab (a NuxtPage descendant) calls this after any resource change, so
-// a newly-uploaded gpkg makes the tab appear without a full page reload.
+// The Files tab calls this after any resource change, so a newly-uploaded eligibile
+// resource makes the tab appear without a full page reload.
 provide(geopfEligibilityRefreshKey, () => refreshGeopfDatasetStatus())
 
-// Stable reference: NuxtPage compares page-key by reference, so an inline function here
+// Stable reference: NuxtPage compares page-key by reference, so an inline function for pageKey
 // would re-trigger the loading indicator whenever `dataset` changes and this re-renders.
 function pageKey(route: RouteLocationNormalizedLoaded) {
   return route.fullPath

From 8b11cf4cded1bf7c1d0d0a1cf2da41de1ea7be55 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 09:43:45 +0200
Subject: [PATCH 14/24] renaming pull push buttons

---
 .../{GeopfPullAction.vue => GeopfPullButton.vue}       |  0
 .../{GeopfPushButton.vue => GeopfPushStatus.vue}       |  0
 components/Datasets/GeopfSyncPage.vue                  | 10 +++++-----
 3 files changed, 5 insertions(+), 5 deletions(-)
 rename components/Datasets/{GeopfPullAction.vue => GeopfPullButton.vue} (100%)
 rename components/Datasets/{GeopfPushButton.vue => GeopfPushStatus.vue} (100%)

diff --git a/components/Datasets/GeopfPullAction.vue b/components/Datasets/GeopfPullButton.vue
similarity index 100%
rename from components/Datasets/GeopfPullAction.vue
rename to components/Datasets/GeopfPullButton.vue
diff --git a/components/Datasets/GeopfPushButton.vue b/components/Datasets/GeopfPushStatus.vue
similarity index 100%
rename from components/Datasets/GeopfPushButton.vue
rename to components/Datasets/GeopfPushStatus.vue
diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index f95d3ae27..69246f728 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -55,7 +55,7 @@
                 {{ resource.format }}
               </td>
               <td>
-                <GeopfPushButton
+                <GeopfPushStatus
                   :resource="resource"
                   :dataset-id="datasetId"
                   :connected="isGeopfConnected"
@@ -71,14 +71,14 @@
           v-else
           class="text-sm text-gray-medium m-0"
         >
-          {{ t("Aucun fichier au format GeoPackage (.gpkg) n'a été trouvé dans ce jeu de données.") }}
+          {{ t("Aucun fichier éligible n'a été trouvé dans ce jeu de données.") }}
         </p>
 
         <div class="flex flex-wrap justify-between items-start gap-2 mt-8 mb-3">
           <h2 class="text-sm font-bold uppercase m-0">
             {{ t('Services récupérés depuis cartes.gouv.fr') }}
           </h2>
-          <GeopfPullAction
+          <GeopfPullButton
             :dataset-id="datasetId"
             :connected="isGeopfConnected"
             :pull="loadedGeopfDatasetStatus.pull"
@@ -154,8 +154,8 @@
 import { BrandedButton, LoadingBlock, useFormatDate, type DatasetV2 } from '@datagouv/components-next'
 import GeopfDatastoreSelector from './GeopfDatastoreSelector.vue'
 import GeopfPanel from './GeopfPanel.vue'
-import GeopfPullAction from './GeopfPullAction.vue'
-import GeopfPushButton from './GeopfPushButton.vue'
+import GeopfPullButton from './GeopfPullButton.vue'
+import GeopfPushStatus from './GeopfPushStatus.vue'
 import AdminTable from '../AdminTable/Table/AdminTable.vue'
 import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
 import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'

From 229f3fd9b441d59f57d9683868746530dfdf637b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 09:43:59 +0200
Subject: [PATCH 15/24] add unit tests

---
 tests-unit/utils/geopf.spec.ts | 50 ++++++++++++++++++++++++++++++++++
 1 file changed, 50 insertions(+)
 create mode 100644 tests-unit/utils/geopf.spec.ts

diff --git a/tests-unit/utils/geopf.spec.ts b/tests-unit/utils/geopf.spec.ts
new file mode 100644
index 000000000..be5a4d63a
--- /dev/null
+++ b/tests-unit/utils/geopf.spec.ts
@@ -0,0 +1,50 @@
+import { describe, expect, it } from 'vitest'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, getGeopfBadgeType, isGeopfReauthRequired } from '~/utils/geopf'
+
+describe('geopfDatasetStatusUrl', () => {
+  it('builds the per-dataset status route', () => {
+    expect(geopfDatasetStatusUrl('abc123')).toBe('/api/1/geopf/status/abc123/')
+  })
+})
+
+describe('geopfDatasetStatusKey', () => {
+  it('builds a key stable for a given dataset id', () => {
+    expect(geopfDatasetStatusKey('abc123')).toBe('geopf-status-abc123')
+    expect(geopfDatasetStatusKey('abc123')).toBe(geopfDatasetStatusKey('abc123'))
+  })
+
+  it('differs across dataset ids', () => {
+    expect(geopfDatasetStatusKey('abc123')).not.toBe(geopfDatasetStatusKey('def456'))
+  })
+})
+
+describe('isGeopfReauthRequired', () => {
+  it('is false for non-object or response-less errors', () => {
+    expect(isGeopfReauthRequired(null)).toBe(false)
+    expect(isGeopfReauthRequired(undefined)).toBe(false)
+    expect(isGeopfReauthRequired('nope')).toBe(false)
+    expect(isGeopfReauthRequired(new Error('boom'))).toBe(false)
+  })
+
+  it('is false for a response with another status', () => {
+    expect(isGeopfReauthRequired({ response: { status: 500 } })).toBe(false)
+    expect(isGeopfReauthRequired({ response: {} })).toBe(false)
+  })
+
+  it('is true only for a 424 response', () => {
+    expect(isGeopfReauthRequired({ response: { status: 424 } })).toBe(true)
+  })
+})
+
+describe('getGeopfBadgeType', () => {
+  it('maps every status to its badge type', () => {
+    expect(getGeopfBadgeType('done')).toBe('success')
+    expect(getGeopfBadgeType('pending')).toBe('primary')
+    expect(getGeopfBadgeType('error')).toBe('danger')
+    expect(getGeopfBadgeType('timeout')).toBe('danger')
+  })
+
+  it('falls back to secondary for null (never run)', () => {
+    expect(getGeopfBadgeType(null)).toBe('secondary')
+  })
+})

From 1f9bc8a2ddde0610fc292c4a2e1b5348a8fb8f0b Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 09:51:12 +0200
Subject: [PATCH 16/24] better perm check on GeopfSyncPage

---
 components/Datasets/GeopfSyncPage.vue | 15 +++++----------
 pages/admin/datasets/[id]/geopf.vue   |  5 ++++-
 2 files changed, 9 insertions(+), 11 deletions(-)

diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index 69246f728..abcd45c7a 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -2,7 +2,6 @@
   <div class="bg-white fr-p-3w">
     <template v-if="canEdit">
       <GeopfPanel
-        v-if="dataset"
         :dataset-id="dataset.id"
         :connected="isGeopfConnected"
         :reauth-required="reauthRequired"
@@ -160,21 +159,17 @@ import AdminTable from '../AdminTable/Table/AdminTable.vue'
 import AdminTableTh from '../AdminTable/Table/AdminTableTh.vue'
 import { geopfDatasetStatusKey, geopfDatasetStatusUrl, type GeopfDatasetStatus } from '~/utils/geopf'
 
+const props = defineProps<{
+  dataset: DatasetV2
+}>()
+
 const route = useRoute()
 const { t } = useTranslation()
 const { formatDate } = useFormatDate()
 
 const datasetId = computed(() => String(route.params.id))
 
-// Only for the permission check; dedupes with the parent admin layout's identical call.
-const datasetUrl = computed(() => `/api/2/datasets/${datasetId.value}/`)
-const { data: dataset } = await useAPI<DatasetV2>(datasetUrl, {
-  redirectOn404: true,
-  headers: {
-    'X-Get-Datasets-Full-Objects': 'True',
-  },
-})
-const canEdit = computed(() => dataset.value?.permissions.edit_resources ?? false)
+const canEdit = computed(() => props.dataset.permissions.edit_resources)
 
 // Everything both tables render, already filtered and projected by udata.
 const { data: geopfDatasetStatus, status, refresh: refreshGeopfDatasetStatus } = await useAPI<GeopfDatasetStatus>(
diff --git a/pages/admin/datasets/[id]/geopf.vue b/pages/admin/datasets/[id]/geopf.vue
index ee4e2c4c1..0fdcb7143 100644
--- a/pages/admin/datasets/[id]/geopf.vue
+++ b/pages/admin/datasets/[id]/geopf.vue
@@ -1,5 +1,8 @@
 <template>
-  <GeopfSyncPage v-if="config.public.geopfEnabled" />
+  <GeopfSyncPage
+    v-if="config.public.geopfEnabled"
+    :dataset="dataset"
+  />
 </template>
 
 <script setup lang="ts">

From a14ade8d385776e3f48bbfe85f11d058dfa4dba2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 10:35:30 +0200
Subject: [PATCH 17/24] simplify badges in
 components/Datasets/GeopfPushStatus.vue

---
 components/Datasets/GeopfPullButton.vue |  2 +-
 components/Datasets/GeopfPushStatus.vue |  8 ++++----
 tests-unit/utils/geopf.spec.ts          | 15 +--------------
 utils/geopf.ts                          | 16 ----------------
 4 files changed, 6 insertions(+), 35 deletions(-)

diff --git a/components/Datasets/GeopfPullButton.vue b/components/Datasets/GeopfPullButton.vue
index cd8c6cdf9..2925c5f13 100644
--- a/components/Datasets/GeopfPullButton.vue
+++ b/components/Datasets/GeopfPullButton.vue
@@ -55,7 +55,7 @@ const { formatDate } = useFormatDate()
 
 const disabledReason = computed(() => {
   if (props.connected !== true) return t('Connectez-vous à cartes.gouv.fr pour récupérer les services.')
-  if (!props.ficheUrl) return t('Envoyez d\'abord un fichier au format GeoPackage (.gpkg) vers cartes.gouv.fr.')
+  if (!props.ficheUrl) return t('Envoyez d\'abord un fichier éligible vers cartes.gouv.fr.')
   return null
 })
 
diff --git a/components/Datasets/GeopfPushStatus.vue b/components/Datasets/GeopfPushStatus.vue
index 7964ce586..e026ed6c5 100644
--- a/components/Datasets/GeopfPushStatus.vue
+++ b/components/Datasets/GeopfPushStatus.vue
@@ -22,7 +22,7 @@
   <AdminBadge
     v-else-if="push.status === 'pending'"
     size="xs"
-    :type="getGeopfBadgeType(push.status)"
+    type="primary"
   >
     {{ t('Envoi en cours…') }}
   </AdminBadge>
@@ -33,7 +33,7 @@
   >
     <AdminBadge
       size="xs"
-      :type="getGeopfBadgeType(push.status)"
+      type="success"
     >
       {{ t('Synchronisé') }}
     </AdminBadge>
@@ -52,7 +52,7 @@
     <Tooltip>
       <AdminBadge
         size="xs"
-        :type="getGeopfBadgeType(push.status)"
+        type="danger"
       >
         {{ push.status === 'timeout' ? t('Délai dépassé') : t("Échec de l'envoi") }}
       </AdminBadge>
@@ -78,7 +78,7 @@
 <script setup lang="ts">
 import { BrandedButton, Tooltip, useFormatDate } from '@datagouv/components-next'
 import { RiRefreshLine, RiUploadCloud2Line } from '@remixicon/vue'
-import { getGeopfBadgeType, isGeopfReauthRequired, type GeopfPushableResource } from '~/utils/geopf'
+import { isGeopfReauthRequired, type GeopfPushableResource } from '~/utils/geopf'
 
 const props = defineProps<{
   resource: GeopfPushableResource
diff --git a/tests-unit/utils/geopf.spec.ts b/tests-unit/utils/geopf.spec.ts
index be5a4d63a..b57c81e65 100644
--- a/tests-unit/utils/geopf.spec.ts
+++ b/tests-unit/utils/geopf.spec.ts
@@ -1,5 +1,5 @@
 import { describe, expect, it } from 'vitest'
-import { geopfDatasetStatusKey, geopfDatasetStatusUrl, getGeopfBadgeType, isGeopfReauthRequired } from '~/utils/geopf'
+import { geopfDatasetStatusKey, geopfDatasetStatusUrl, isGeopfReauthRequired } from '~/utils/geopf'
 
 describe('geopfDatasetStatusUrl', () => {
   it('builds the per-dataset status route', () => {
@@ -35,16 +35,3 @@ describe('isGeopfReauthRequired', () => {
     expect(isGeopfReauthRequired({ response: { status: 424 } })).toBe(true)
   })
 })
-
-describe('getGeopfBadgeType', () => {
-  it('maps every status to its badge type', () => {
-    expect(getGeopfBadgeType('done')).toBe('success')
-    expect(getGeopfBadgeType('pending')).toBe('primary')
-    expect(getGeopfBadgeType('error')).toBe('danger')
-    expect(getGeopfBadgeType('timeout')).toBe('danger')
-  })
-
-  it('falls back to secondary for null (never run)', () => {
-    expect(getGeopfBadgeType(null)).toBe('secondary')
-  })
-})
diff --git a/utils/geopf.ts b/utils/geopf.ts
index dd7ad641f..922ce584d 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -1,5 +1,3 @@
-import type { AdminBadgeType } from '~/types/types'
-
 export { isGeopfSynced } from '@datagouv/components-next'
 
 export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
@@ -64,17 +62,3 @@ export function isGeopfReauthRequired(error: unknown): boolean {
   const response = (error as { response?: { status?: number } }).response
   return response?.status === 424
 }
-
-export function getGeopfBadgeType(status: GeopfPushStatus | GeopfPullStatus | null): AdminBadgeType {
-  switch (status) {
-    case 'done':
-      return 'success'
-    case 'pending':
-      return 'primary'
-    case 'error':
-    case 'timeout':
-      return 'danger'
-    default:
-      return 'secondary'
-  }
-}

From 199d2576071fabd8bc112d9edcd5058ff44d23c5 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 10:45:24 +0200
Subject: [PATCH 18/24] disabled reason

---
 components/Datasets/GeopfPushStatus.vue                   | 3 +--
 .../src/components/ResourceAccordion/EditButton.vue       | 8 ++++----
 .../components/ResourceAccordion/ResourceAccordion.vue    | 6 +++++-
 3 files changed, 10 insertions(+), 7 deletions(-)

diff --git a/components/Datasets/GeopfPushStatus.vue b/components/Datasets/GeopfPushStatus.vue
index e026ed6c5..871f567e2 100644
--- a/components/Datasets/GeopfPushStatus.vue
+++ b/components/Datasets/GeopfPushStatus.vue
@@ -113,8 +113,7 @@ const startPush = async () => {
       method: 'POST',
       body: { datastore_id: props.datastoreId },
     })
-    // Awaited: udata marks the resource `pending` before enqueueing, so this returns
-    // the new status and the button never re-enables in between.
+    // Awaited: udata marks the resource `pending` before enqueueing, so this returns the new status
     await props.refresh()
   }
   catch (error) {
diff --git a/datagouv-components/src/components/ResourceAccordion/EditButton.vue b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
index aa02ec893..b785d63a4 100644
--- a/datagouv-components/src/components/ResourceAccordion/EditButton.vue
+++ b/datagouv-components/src/components/ResourceAccordion/EditButton.vue
@@ -4,8 +4,8 @@
     icon-only
     :icon="RiPencilLine"
     color="warning"
-    :disabled="disabled"
-    :title="disabled ? t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : t('Éditer le fichier')"
+    :disabled="!!disabledReason"
+    :title="disabledReason ?? t('Éditer le fichier')"
     data-testid="edit-button"
   />
 </template>
@@ -20,12 +20,12 @@ type Props = {
   datasetId: string
   isCommunityResource?: boolean
   resourceId: string
-  disabled?: boolean
+  disabledReason?: string | null
 }
 
 const props = withDefaults(defineProps<Props>(), {
   isCommunityResource: false,
-  disabled: false,
+  disabledReason: null,
 })
 
 const { t } = useTranslation()
diff --git a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
index 05e659d97..2bd695368 100644
--- a/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
+++ b/datagouv-components/src/components/ResourceAccordion/ResourceAccordion.vue
@@ -163,7 +163,7 @@
             :dataset-id="dataset.id"
             :resource-id="resource.id"
             :is-community-resource="isCommunityResource"
-            :disabled="isGeopfSynced(resource)"
+            :disabled-reason="editDisabledReason"
             size="xs"
           />
         </p>
@@ -373,6 +373,10 @@ const hasPmtiles = computed(() => {
   return props.resource.extras['analysis:parsing:pmtiles_url'] || props.resource.format === 'pmtiles'
 })
 
+const editDisabledReason = computed(() => {
+  return isGeopfSynced(props.resource) ? t('Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr') : null
+})
+
 const hasDatafairPreview = computed(() => {
   // Checks if there are the corresponding extras for a datafair preview.
   // Limited only to datasets published by certified organizations since it will load an iframe.

From 222710ea34b56fc871fa95a25004bd74ae04f2a2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 10:54:54 +0200
Subject: [PATCH 19/24] nitpicks

---
 datagouv-components/src/functions/resources.ts | 2 +-
 utils/geopf.ts                                 | 4 +---
 2 files changed, 2 insertions(+), 4 deletions(-)

diff --git a/datagouv-components/src/functions/resources.ts b/datagouv-components/src/functions/resources.ts
index f9abe9aba..b5f8630ac 100644
--- a/datagouv-components/src/functions/resources.ts
+++ b/datagouv-components/src/functions/resources.ts
@@ -179,7 +179,7 @@ export function getResourceExternalUrl(dataset: Dataset | DatasetV2 | Omit<Datas
   return `${dataset.page}${isCommunityResource(resource) ? '/community-resources' : ''}?resource_id=${resource.id}`
 }
 
-// Resources whose local edition would diverge from what cartes.gouv.fr publishes.
+// Resources that are (being) pushed to geopf or pulled from geopf
 export function isGeopfSynced(resource: Resource | CommunityResource): boolean {
   const status = resource.extras['geopf:push:status']
   return status === 'done' || status === 'pending' || typeof resource.extras['geopf:offering:id'] === 'string'
diff --git a/utils/geopf.ts b/utils/geopf.ts
index 922ce584d..77b1e6c93 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -3,8 +3,6 @@ export { isGeopfSynced } from '@datagouv/components-next'
 export type GeopfPushStatus = 'pending' | 'done' | 'error' | 'timeout'
 export type GeopfPullStatus = 'pending' | 'done' | 'error'
 
-// Shape of `GET /api/1/geopf/status/<dataset_id>/` (see udata/docs/geopf.md).
-// A null `status` means "never run".
 export type GeopfPushableResource = {
   id: string
   title: string
@@ -28,6 +26,7 @@ export type GeopfOfferingResource = {
   last_synced_at: string | null
 }
 
+// Shape of `GET /api/1/geopf/status/<dataset_id>/`
 export type GeopfDatasetStatus = {
   datastore_id: string | null
   fiche_url: string | null
@@ -50,7 +49,6 @@ export function geopfDatasetStatusKey(datasetId: string): string {
   return `geopf-status-${datasetId}`
 }
 
-// Raw pass-through of geopf's own API shape (GET /datastores).
 export type GeopfDatastore = {
   datastore_id: string
   name: string

From 913fa65ccc6525c707fe1301afcc3a93078b13df Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 11:42:01 +0200
Subject: [PATCH 20/24] add e2e tests

---
 .github/workflows/ci.yml     |  1 +
 tests/datasets/geopf.spec.ts | 85 ++++++++++++++++++++++++++++++++++++
 tests/helpers.ts             |  8 ++--
 3 files changed, 91 insertions(+), 3 deletions(-)
 create mode 100644 tests/datasets/geopf.spec.ts

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index e6986f0fd..2c3cb2c2e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -248,6 +248,7 @@ jobs:
           NUXT_SITE_URL: http://localhost:3000
           NUXT_PUBLIC_CHARTS_API_BASE: http://localhost:7000
           NUXT_PUBLIC_CADA_RESOURCE_ID: 3a6d6fe3-8548-43ed-ad09-72052771447c
+          NUXT_PUBLIC_GEOPF_ENABLED: "true"
         run: |
           # Start cdata server in background using pre-built artifacts
           PORT=3000 node .output/server/index.mjs > cdata.log 2>&1 &
diff --git a/tests/datasets/geopf.spec.ts b/tests/datasets/geopf.spec.ts
new file mode 100644
index 000000000..16ba5dd8b
--- /dev/null
+++ b/tests/datasets/geopf.spec.ts
@@ -0,0 +1,85 @@
+import { test, expect } from '../base'
+import { API_BASE, createDataset, createRemoteResource, deleteDatasets } from '../helpers'
+
+const createdDatasets: Array<string> = []
+
+test.afterEach(async ({ request }) => {
+  await deleteDatasets(request, createdDatasets)
+})
+
+test.describe('Géoplateforme sync', () => {
+  test('the geopf tab appears once an eligible file is uploaded, without a reload', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf eligibility ${uniqueId}`, 'Dataset pour tester la synchronisation cartes.gouv.fr')
+    createdDatasets.push(dataset.id)
+
+    // Seed a non-eligible file
+    await request.post(`${API_BASE}/api/1/datasets/${dataset.id}/upload/`, {
+      multipart: {
+        file: {
+          name: `original-${uniqueId}.csv`,
+          mimeType: 'text/csv',
+          buffer: Buffer.from('col_a,col_b\n1,2\n'),
+        },
+      },
+    })
+
+    await page.goto(`/admin/datasets/${dataset.id}/files`)
+    await page.waitForLoadState('networkidle')
+
+    await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).not.toBeVisible()
+
+    // Replace the file with a .gpkg: the Files tab's own mutation should tell
+    // the admin layout to recheck eligibility, surfacing the tab with no reload.
+    await page.getByRole('button', { name: 'Éditer le fichier' }).click()
+    const dialog = page.getByRole('dialog')
+    await expect(dialog.getByRole('heading', { name: 'Métadonnées du fichier' })).toBeVisible()
+
+    const fileChooserPromise = page.waitForEvent('filechooser')
+    await dialog.getByRole('button', { name: 'Parcourir' }).click()
+    const fileChooser = await fileChooserPromise
+    await fileChooser.setFiles({
+      name: `replacement-${uniqueId}.gpkg`,
+      mimeType: 'application/geopackage+sqlite3',
+      buffer: Buffer.from('not a real geopackage, only the extension matters here'),
+    })
+    await dialog.getByRole('button', { name: 'Valider' }).click()
+    await expect(page.getByText('Fichier mis à jour !')).toBeVisible()
+
+    await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).toBeVisible()
+  })
+
+  test('shows the disconnected banner and blocks push when not linked to Géoplateforme', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf disconnected ${uniqueId}`, 'Dataset pour tester l\'état déconnecté')
+    createdDatasets.push(dataset.id)
+    await createRemoteResource(request, dataset.id, `communes-${uniqueId}`, { format: 'gpkg' })
+
+    await page.goto(`/admin/datasets/${dataset.id}/geopf`)
+    await page.waitForLoadState('networkidle')
+
+    await expect(page.getByText('Non connecté à cartes.gouv.fr')).toBeVisible()
+    const connectLink = page.getByRole('link', { name: 'Se connecter' })
+    await expect(connectLink).toBeVisible()
+    await expect(connectLink).toHaveAttribute('href', new RegExp(`/api/1/geopf/login/\\?dataset_id=${dataset.id}`))
+
+    await expect(page.getByRole('button', { name: 'Envoyer vers cartes.gouv.fr' })).toBeDisabled()
+  })
+
+  test('a resource synced with geopf cannot be edited from the Files tab', async ({ page, request }) => {
+    const uniqueId = Date.now()
+    const dataset = await createDataset(request, `Test geopf synced resource ${uniqueId}`, 'Dataset pour tester l\'édition')
+    createdDatasets.push(dataset.id)
+    await createRemoteResource(request, dataset.id, `geopf-done-${uniqueId}`, { extras: { 'geopf:push:status': 'done' } })
+    await createRemoteResource(request, dataset.id, `geopf-untouched-${uniqueId}`)
+
+    await page.goto(`/admin/datasets/${dataset.id}/files`)
+    await page.waitForLoadState('networkidle')
+
+    const syncedRow = page.locator('tbody tr').filter({ hasText: `geopf-done-${uniqueId}` })
+    await expect(syncedRow.getByRole('button', { name: 'Vous ne pouvez pas modifier cette ressource car elle est synchronisée avec cartes.gouv.fr' })).toBeDisabled()
+
+    const untouchedRow = page.locator('tbody tr').filter({ hasText: `geopf-untouched-${uniqueId}` })
+    await expect(untouchedRow.getByRole('button', { name: 'Éditer le fichier' })).toBeEnabled()
+  })
+})
diff --git a/tests/helpers.ts b/tests/helpers.ts
index 50297df3c..bd1630beb 100644
--- a/tests/helpers.ts
+++ b/tests/helpers.ts
@@ -43,14 +43,16 @@ export async function createDataset(request: APIRequestContext, title: string, d
   return await response.json()
 }
 
-export async function createRemoteResource(request: APIRequestContext, datasetId: string, title: string): Promise<ApiResource> {
+export async function createRemoteResource(request: APIRequestContext, datasetId: string, title: string, options: { format?: string, extras?: Record<string, unknown> } = {}): Promise<ApiResource> {
+  const { format = 'csv', extras } = options
   const response = await request.post(`${API_BASE}/api/1/datasets/${datasetId}/resources/`, {
     data: {
       title,
       type: 'main',
       filetype: 'remote',
-      url: `https://example.com/${datasetId}/${encodeURIComponent(title)}.csv`,
-      format: 'csv',
+      url: `https://example.com/${datasetId}/${encodeURIComponent(title)}.${format}`,
+      format,
+      ...(extras ? { extras } : {}),
     },
   })
   return await response.json()

From ea40b9257d1f38630e1f0f2d00ea636bc0d63e91 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 12:17:07 +0200
Subject: [PATCH 21/24] debug e2e

---
 tests/datasets/geopf.spec.ts | 11 ++++++++++-
 tests/helpers.ts             |  3 +++
 2 files changed, 13 insertions(+), 1 deletion(-)

diff --git a/tests/datasets/geopf.spec.ts b/tests/datasets/geopf.spec.ts
index 16ba5dd8b..ef8360161 100644
--- a/tests/datasets/geopf.spec.ts
+++ b/tests/datasets/geopf.spec.ts
@@ -14,7 +14,7 @@ test.describe('Géoplateforme sync', () => {
     createdDatasets.push(dataset.id)
 
     // Seed a non-eligible file
-    await request.post(`${API_BASE}/api/1/datasets/${dataset.id}/upload/`, {
+    const uploadResponse = await request.post(`${API_BASE}/api/1/datasets/${dataset.id}/upload/`, {
       multipart: {
         file: {
           name: `original-${uniqueId}.csv`,
@@ -23,6 +23,10 @@ test.describe('Géoplateforme sync', () => {
         },
       },
     })
+    if (!uploadResponse.ok()) {
+      throw new Error(`Failed to seed the original file: ${uploadResponse.status()} ${(await uploadResponse.text()).slice(0, 300)}`)
+    }
+    const { id: resourceId } = await uploadResponse.json()
 
     await page.goto(`/admin/datasets/${dataset.id}/files`)
     await page.waitForLoadState('networkidle')
@@ -46,6 +50,11 @@ test.describe('Géoplateforme sync', () => {
     await dialog.getByRole('button', { name: 'Valider' }).click()
     await expect(page.getByText('Fichier mis à jour !')).toBeVisible()
 
+    // Disambiguates a future failure here: was the new format actually persisted
+    // (a backend/upload concern), or is the eligibility-refresh wiring broken?
+    const updatedResource = await (await request.get(`${API_BASE}/api/1/datasets/${dataset.id}/resources/${resourceId}/`)).json()
+    expect(updatedResource.format).toBe('gpkg')
+
     await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).toBeVisible()
   })
 
diff --git a/tests/helpers.ts b/tests/helpers.ts
index bd1630beb..2d0878a59 100644
--- a/tests/helpers.ts
+++ b/tests/helpers.ts
@@ -55,6 +55,9 @@ export async function createRemoteResource(request: APIRequestContext, datasetId
       ...(extras ? { extras } : {}),
     },
   })
+  if (!response.ok()) {
+    throw new Error(`Failed to create resource "${title}": ${response.status()} ${(await response.text()).slice(0, 300)}`)
+  }
   return await response.json()
 }
 

From 832058a94bdda01e7ee462d07bf08a58fe0227b0 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 20 Aug 2026 13:47:49 +0200
Subject: [PATCH 22/24] e2e need udata geopf

---
 .github/workflows/ci.yml     | 4 +++-
 tests/datasets/geopf.spec.ts | 6 ------
 2 files changed, 3 insertions(+), 7 deletions(-)

diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index 2c3cb2c2e..854002a7e 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -148,7 +148,9 @@ jobs:
         with:
           repository: opendatateam/udata
           path: ${{ env.UDATA_WORKING_DIR }}
-          ref: main
+          # FIXME: geopf lives on this branch, not yet merged to main. Point back
+          # to `main` once the udata geopf PR (feat/geopf/init) merges.
+          ref: feat/geopf/init
 
       - name: Set up uv
         uses: astral-sh/setup-uv@v6
diff --git a/tests/datasets/geopf.spec.ts b/tests/datasets/geopf.spec.ts
index ef8360161..a29cd069e 100644
--- a/tests/datasets/geopf.spec.ts
+++ b/tests/datasets/geopf.spec.ts
@@ -26,7 +26,6 @@ test.describe('Géoplateforme sync', () => {
     if (!uploadResponse.ok()) {
       throw new Error(`Failed to seed the original file: ${uploadResponse.status()} ${(await uploadResponse.text()).slice(0, 300)}`)
     }
-    const { id: resourceId } = await uploadResponse.json()
 
     await page.goto(`/admin/datasets/${dataset.id}/files`)
     await page.waitForLoadState('networkidle')
@@ -50,11 +49,6 @@ test.describe('Géoplateforme sync', () => {
     await dialog.getByRole('button', { name: 'Valider' }).click()
     await expect(page.getByText('Fichier mis à jour !')).toBeVisible()
 
-    // Disambiguates a future failure here: was the new format actually persisted
-    // (a backend/upload concern), or is the eligibility-refresh wiring broken?
-    const updatedResource = await (await request.get(`${API_BASE}/api/1/datasets/${dataset.id}/resources/${resourceId}/`)).json()
-    expect(updatedResource.format).toBe('gpkg')
-
     await expect(page.getByRole('link', { name: 'Synchronisation cartes.gouv.fr' })).toBeVisible()
   })
 

From b2c2757cd1252c556c217c87f7c31144bdfb53b2 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Thu, 27 Aug 2026 15:45:26 +0200
Subject: [PATCH 23/24] new backend version + nitpicks on urls

---
 components/Datasets/GeopfSyncPage.vue | 10 +++++-----
 components/SiteHeader/SiteHeader.vue  |  3 +++
 utils/geopf.ts                        | 12 ++++++++----
 utils/helpers.ts                      |  6 +++++-
 4 files changed, 21 insertions(+), 10 deletions(-)

diff --git a/components/Datasets/GeopfSyncPage.vue b/components/Datasets/GeopfSyncPage.vue
index abcd45c7a..431c73ad1 100644
--- a/components/Datasets/GeopfSyncPage.vue
+++ b/components/Datasets/GeopfSyncPage.vue
@@ -11,7 +11,7 @@
 
       <GeopfDatastoreSelector
         v-model="datastoreId"
-        :pinned-datastore-id="geopfDatasetStatus?.datastore_id ?? null"
+        :pinned-datastore-id="geopfDatasetStatus?.push.datastore_id ?? null"
         :connected="isGeopfConnected"
         class="fr-mb-3w"
       />
@@ -81,7 +81,7 @@
             :dataset-id="datasetId"
             :connected="isGeopfConnected"
             :pull="loadedGeopfDatasetStatus.pull"
-            :fiche-url="loadedGeopfDatasetStatus.fiche_url"
+            :fiche-url="loadedGeopfDatasetStatus.push.fiche_url"
             :refresh="refreshGeopfDatasetStatus"
             @reauth-required="reauthRequired = true"
           />
@@ -116,7 +116,7 @@
                 {{ resource.format }}
               </td>
               <td>
-                {{ formatDate(resource.last_synced_at) }}
+                {{ formatDate(resource.offering.last_synced_at) }}
               </td>
             </tr>
           </tbody>
@@ -129,10 +129,10 @@
         </p>
 
         <BrandedButton
-          v-if="loadedGeopfDatasetStatus.fiche_url"
+          v-if="loadedGeopfDatasetStatus.push.fiche_url"
           color="secondary"
           size="xs"
-          :href="loadedGeopfDatasetStatus.fiche_url"
+          :href="loadedGeopfDatasetStatus.push.fiche_url"
           new-tab
           class="mt-3"
         >
diff --git a/components/SiteHeader/SiteHeader.vue b/components/SiteHeader/SiteHeader.vue
index 87334b0fb..a443f0de4 100644
--- a/components/SiteHeader/SiteHeader.vue
+++ b/components/SiteHeader/SiteHeader.vue
@@ -631,6 +631,9 @@ onMounted(() => {
     if (message) {
       toast[message.type](message.text)
     }
+
+    // Consume the flash: strip it from the URL so it can't resurface on a later reload.
+    router.replace({ query: { ...route.query, flash: undefined, info: undefined, error: undefined } })
   }
 })
 
diff --git a/utils/geopf.ts b/utils/geopf.ts
index 77b1e6c93..226b6d8b6 100644
--- a/utils/geopf.ts
+++ b/utils/geopf.ts
@@ -22,14 +22,18 @@ export type GeopfOfferingResource = {
   title: string
   format: string | null
   url: string | null
-  offering_id: string
-  last_synced_at: string | null
+  offering: {
+    id: string
+    last_synced_at: string | null
+  }
 }
 
 // Shape of `GET /api/1/geopf/status/<dataset_id>/`
 export type GeopfDatasetStatus = {
-  datastore_id: string | null
-  fiche_url: string | null
+  push: {
+    datastore_id: string | null
+    fiche_url: string | null
+  }
   pull: {
     status: GeopfPullStatus | null
     last_synced_at: string | null
diff --git a/utils/helpers.ts b/utils/helpers.ts
index 6f0347c16..39bc68222 100644
--- a/utils/helpers.ts
+++ b/utils/helpers.ts
@@ -28,9 +28,13 @@ function trimEndSlash(url: string): string {
 export function useIsCurrentUrl() {
   const absoluteUrlToRelative = useAbsoluteUrlToRelative()
   const route = useRoute()
+  const router = useRouter()
 
   return (url: string): boolean => {
-    return trimEndSlash(absoluteUrlToRelative(url)) === trimEndSlash(route.fullPath)
+    // Compare paths only: nav/tab links never carry a query string of their own,
+    // so a route with one (e.g. `?flash=connected`) shouldn't fail the match.
+    const urlPath = router.resolve(absoluteUrlToRelative(url)).path
+    return trimEndSlash(urlPath) === trimEndSlash(route.path)
   }
 }
 

From b43c1be928c9a40ea88bfca421169fcef4f50e60 Mon Sep 17 00:00:00 2001
From: =?UTF-8?q?Alexandre=20Bult=C3=A9?= <alexandre@bulte.net>
Date: Mon, 31 Aug 2026 16:57:16 +0200
Subject: [PATCH 24/24] migrate isGeopfSynced to new backend

---
 .../src/functions/resources.ts                |  4 +---
 datagouv-components/src/types/resources.ts    |  6 ++++++
 .../datagouv-components/resources.spec.ts     | 21 ++++++++-----------
 tests/datasets/geopf.spec.ts                  | 10 ++++++++-
 4 files changed, 25 insertions(+), 16 deletions(-)

diff --git a/datagouv-components/src/functions/resources.ts b/datagouv-components/src/functions/resources.ts
index b5f8630ac..b3f95f0b1 100644
--- a/datagouv-components/src/functions/resources.ts
+++ b/datagouv-components/src/functions/resources.ts
@@ -179,10 +179,8 @@ export function getResourceExternalUrl(dataset: Dataset | DatasetV2 | Omit<Datas
   return `${dataset.page}${isCommunityResource(resource) ? '/community-resources' : ''}?resource_id=${resource.id}`
 }
 
-// Resources that are (being) pushed to geopf or pulled from geopf
 export function isGeopfSynced(resource: Resource | CommunityResource): boolean {
-  const status = resource.extras['geopf:push:status']
-  return status === 'done' || status === 'pending' || typeof resource.extras['geopf:offering:id'] === 'string'
+  return resource.geopf?.push_status != null || typeof resource.geopf?.offering_id === 'string'
 }
 
 export function getResourceFilesize(resource: Resource): null | number {
diff --git a/datagouv-components/src/types/resources.ts b/datagouv-components/src/types/resources.ts
index 2a1d9082d..f5d9ab02b 100644
--- a/datagouv-components/src/types/resources.ts
+++ b/datagouv-components/src/types/resources.ts
@@ -12,6 +12,11 @@ export type FileResourceFileType = 'file'
 
 export type ResourceFileType = RemoteResourceFileType | FileResourceFileType
 
+export type GeopfResourceMetadata = {
+  push_status?: 'pending' | 'done' | 'error' | 'timeout' | null
+  offering_id?: string | null
+}
+
 export type Resource = {
   id: string
   title: string
@@ -22,6 +27,7 @@ export type Resource = {
   extras: Record<string, unknown>
   metrics: { views: number }
   harvest: Harvest
+  geopf: GeopfResourceMetadata | null
   filesize: number | null
   filetype: ResourceFileType
   format: string
diff --git a/tests-unit/datagouv-components/resources.spec.ts b/tests-unit/datagouv-components/resources.spec.ts
index 07ad5b82f..802fc1924 100644
--- a/tests-unit/datagouv-components/resources.spec.ts
+++ b/tests-unit/datagouv-components/resources.spec.ts
@@ -72,25 +72,22 @@ describe('isCommunityResource', () => {
 })
 
 describe('isGeopfSynced', () => {
-  it('is false without any geopf extras', () => {
-    expect(isGeopfSynced({ extras: {} } as Resource)).toBe(false)
+  it('is false without any geopf metadata', () => {
+    expect(isGeopfSynced({ geopf: null } as Resource)).toBe(false)
   })
 
-  it('is true while a push is pending, or once it succeeded', () => {
-    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'pending' } } as unknown as Resource)).toBe(true)
-    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'done' } } as unknown as Resource)).toBe(true)
-  })
-
-  it('is false for a failed or timed out push', () => {
-    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'error' } } as unknown as Resource)).toBe(false)
-    expect(isGeopfSynced({ extras: { 'geopf:push:status': 'timeout' } } as unknown as Resource)).toBe(false)
+  it('is true once any push has been attempted, whatever its outcome', () => {
+    expect(isGeopfSynced({ geopf: { push_status: 'pending' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'done' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'error' } } as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { push_status: 'timeout' } } as Resource)).toBe(true)
   })
 
   it('is true for a resource pulled back as an offering', () => {
-    expect(isGeopfSynced({ extras: { 'geopf:offering:id': 'offering-1' } } as unknown as Resource)).toBe(true)
+    expect(isGeopfSynced({ geopf: { offering_id: 'offering-1' } } as Resource)).toBe(true)
   })
 
   it('ignores a non-string offering id', () => {
-    expect(isGeopfSynced({ extras: { 'geopf:offering:id': 42 } } as unknown as Resource)).toBe(false)
+    expect(isGeopfSynced({ geopf: { offering_id: 42 as unknown as string } } as Resource)).toBe(false)
   })
 })
diff --git a/tests/datasets/geopf.spec.ts b/tests/datasets/geopf.spec.ts
index a29cd069e..8c192a54f 100644
--- a/tests/datasets/geopf.spec.ts
+++ b/tests/datasets/geopf.spec.ts
@@ -73,9 +73,17 @@ test.describe('Géoplateforme sync', () => {
     const uniqueId = Date.now()
     const dataset = await createDataset(request, `Test geopf synced resource ${uniqueId}`, 'Dataset pour tester l\'édition')
     createdDatasets.push(dataset.id)
-    await createRemoteResource(request, dataset.id, `geopf-done-${uniqueId}`, { extras: { 'geopf:push:status': 'done' } })
+    await createRemoteResource(request, dataset.id, `geopf-done-${uniqueId}`)
     await createRemoteResource(request, dataset.id, `geopf-untouched-${uniqueId}`)
 
+    // resource.geopf is readonly, only ever set by the real push/pull flow: serve the
+    // real Files-tab payload back with the first resource patched as synced.
+    const payload = await (await request.get(`${API_BASE}/api/2/datasets/${dataset.id}/resources/`)).json()
+    const syncedResource = payload.data.find((r: { title: string }) => r.title === `geopf-done-${uniqueId}`)
+    syncedResource.geopf = { push_status: 'done' }
+
+    await page.route(new RegExp(`/api/2/datasets/${dataset.id}/resources/`), route => route.fulfill({ json: payload }))
+
     await page.goto(`/admin/datasets/${dataset.id}/files`)
     await page.waitForLoadState('networkidle')