Het ontwikkelen van een geavanceerde contentarchiverings- en opschoonstrategie voor je Sanity CMS-project vereist een gestructureerde aanpak die automatisering en naleving van compliance waarborgt. Hier is een gedetailleerd voorstel: 1. Bepaal en definieer criteria en workflows - Archiveringscriteria: - Content (bijvoorbeeld blogposts, statische pagina's) die niet is bijgewerkt sinds meer dan 2 jaar. - Opschoningsfrequentie: - Wekelijkse controle en verwijdering van verouderde content. - Contenttypes: - Specifiek gericht op blogposts en statische pagina's. - Compliance: - Na archivering moet data permanent verwijderd worden volgens de regelgeving. 2. Automatisering opzetten - Data detectie: - Schrijf een script (bijvoorbeeld in Node.js of via Sanity's API) dat wekelijks draait en zoekt naar content die voldoet aan de criteria (geen updates in >2 jaar). - Archivering: - Wanneer content wordt geïdentificeerd, kopieer deze naar een beveiligde archiefopslag (bijv. een aparte database, cloud storage, of een archief-bucket). - Verwijdering: - Na succesvolle archivering en conform de compliance-eisen, verwijder de originele content uit Sanity. 3. Integratie in bestaande workflows - Automatisering: - Gebruik CI/CD pipelines of cron-jobs (bijvoorbeeld met GitHub Actions, CircleCI, of een eigen server) die het script wekelijks uitvoeren. - Sanity API gebruik: - Gebruik de Sanity Content Lake API om queries uit te voeren, content te archiveren en te verwijderen. - Notificaties: - Configureer e-mailnotificaties of dashboards voor overzicht en controle. - Documentatie en logging: - Log alle acties voor auditdoeleinden en naleving. 4. Naleving en dataprivacy - Data permanent verwijderen: - Zorg dat verwijderde data niet terug te herstellen is en dat je voldoet aan de AVG/GDPR-regels. - Verificatie: - Voer periodieke audits uit om te bevestigen dat data correct is verwijderd en archieven veilig zijn opgeslagen. 5. Extra aanbevelingen - Test het proces eerst op een testomgeving. - Implementeer fallback procedures voor het geval van fouten. - Overweeg het gebruik van Sanity webhooks voor real-time acties, indien relevant. Door deze strategie te automatiseren en goed te integreren in je bestaande workflows, haal je een efficiënte, conforme en veilige content archivering en opschoning binnen jouw Sanity CMS-omgeving.

Absoluut. Hier is een gedetailleerd, geavanceerd strategieplan voor het archiveren en opschonen van content in uw Sanity CMS, volledig geautomatiseerd en afgestemd op uw specificaties. ### Overzicht van de Strategie We gaan een tweefasenstrategie implementeren: 1. **Archiveringsfase:** Verplaatsen van oude content naar een apart "archief" dataset binnen hetzelfde Sanity project. 2. **Opschoningsfase:** Permanente verwijdering van gearchiveerde content uit de productie-dataset. Dit biedt een veiligheidsbuffer: content wordt eerst gearchiveerd en pas later definitief verwijderd, zodat u eventuele fouten kunt opvangen. --- ### Stap 1: Sanity Dataset & Schema Inrichting #### A. Creëer een Archiefdataset In uw Sanity project (`sanity.config.ts` of via het Sanity Management Dashboard), maakt u een tweede dataset aan, bijvoorbeeld `archive` of `production-archive`. Deze dataset dient als tijdelijke opslag voordat content definitief wordt gewist. **sanity.config.ts (voorbeeld):** ```javascript import {defineConfig} from 'sanity' import {deskTool} from 'sanity/desk' export default defineConfig({ // ... andere configuratie datasets: ['production', 'archive'], // Je hoofddataset en de archiefdataset }) ``` #### B. Breid je Schema uit met Metadata Voeg een veld toe aan je `blogPost` en `page` schema's om de archiveringsstatus en -datum bij te houden. **Schemadefinitie (bijv. in `blogPost.js`):** ```javascript // schemas/blogPost.js export default { name: 'blogPost', title: 'Blogpost', type: 'document', fields: [ // ... jouw bestaande velden (title, body, etc.) { name: 'lastUpdated', title: 'Laatst bijgewerkt op', type: 'datetime', description: 'Datum en tijd van de laatste wijziging. Wordt automatisch bijgewerkt.', options: { dateFormat: 'DD-MM-YYYY', timeFormat: 'HH:mm', }, }, { name: 'isArchived', title: 'Is gearchiveerd?', type: 'boolean', description: 'Geeft aan of dit document is gearchiveerd.', initialValue: false, hidden: true, // Verbergt het voor de redactie-ui }, { name: 'archivedAt', title: 'Gearchiveerd op', type: 'datetime', description: 'Datum en tijd van archivering.', hidden: true, // Verbergt het voor de redactie-ui }, ], initialValue: { lastUpdated: new Date().toISOString(), }, } ``` --- ### Stap 2: Automatisering met Sanity's Scheduled Publishing & Scripts De kern van de automatisering ligt in een gepland script (bijv. een wekelijkse Cron Job) dat de volgende logica uitvoert. #### A. Script 1: Archiveringsscript (Wekelijks uit te voeren) Dit script: 1. Zoekt alle blogposts en pagina's waar `lastUpdated` ouder is dan 2 jaar EN `isArchived` onwaar is. 2. Exporteert deze documenten naar de archiefdataset. 3. Markeert ze in de productie-dataset als gearchiveerd (of verwijdert ze direct, zie opties hieronder). **Technische Implementatie (Node.js script met Sanity Client):** ```javascript // scripts/archiveContent.js import {createClient} from '@sanity/client' import {format, subYears} from 'date-fns' // Configureer clients voor beide datasets const productionClient = createClient({ projectId: 'jouw-project-id', dataset: 'production', useCdn: false, token: 'JE_SECRETE_SANITY_TOKEN_MET_SCHRIJFRECHTEN', // CRUCIAAL }) const archiveClient = createClient({ projectId: 'jouw-project-id', dataset: 'archive', useCdn: false, token: 'JE_SECRETE_SANITY_TOKEN_MET_SCHRIJFRECHTEN', }) async function archiveOldContent() { const twoYearsAgo = subYears(new Date(), 2).toISOString() // 1. Zoek content ouder dan 2 jaar die nog niet gearchiveerd is const query = `*[ _type in ["blogPost", "page"] && lastUpdated < "${twoYearsAgo}" && isArchived != true ]` const documentsToArchive = await productionClient.fetch(query) // 2. Archiveer elk document for (const doc of documentsToArchive) { try { console.log(`Archivering document: ${doc._id} - ${doc.title}`) // Exporteer naar de archiefdataset await archiveClient.createOrReplace({ ...doc, // Overschrijf de `_id` niet, zodat de relatie behouden blijft }) // OPTIE A: Soft-archiveer in productie (veilig) await productionClient .patch(doc._id) .set({ isArchived: true, archivedAt: new Date().toISOString(), }) .commit() // OPTIE B: Verwijder direct uit productie (definitief) // await productionClient.delete(doc._id) } catch (error) { console.error(`Fout bij archiveren van document ${doc._id}:`, error) } } } archiveOldContent().catch(console.error) ``` #### B. Script 2: Definitieve Verwijderingsscript (Optioneel, wekelijks uit te voeren) Als u kiest voor **Optie A (Soft-archivering)**, heeft u een tweede script nodig dat documenten die al een tijdje in het archief zitten (bijv. 1 maand) definitief uit de productie-dataset verwijdert. Dit is uw extra veiligheidsnet. ```javascript // scripts/deleteArchivedContent.js import {createClient} from '@sanity/client' import {subMonths} from 'date-fns' const productionClient = createClient({ // ...zelfde configuratie als hierboven }) async function deleteArchivedContent() { const oneMonthAgo = subMonths(new Date(), 1).toISOString() // Zoek content die meer dan een maand geleden is gearchiveerd const query = `*[ _type in ["blogPost", "page"] && isArchived == true && archivedAt < "${oneMonthAgo}" ]` const documentsToDelete = await productionClient.fetch(query) for (const doc of documentsToDelete) { try { console.log(`Definitief verwijderen document: ${doc._id}`) await productionClient.delete(doc._id) } catch (error) { console.error(`Fout bij verwijderen van document ${doc._id}:`, error) } } } deleteArchivedContent().catch(console.error) ``` --- ### Stap 3: Integratie in Workflow & Planning #### A. Implementeer Hooks voor `lastUpdated` Zorg ervoor dat het `lastUpdated` veld automatisch wordt bijgewerkt bij elke wijziging. Dit kan met een **Document Action** of een **Server-side Hook**. **Voorbeeld van een Document Action (in `sanity.config.ts`):** ```javascript import {defineConfig} from 'sanity' export default defineConfig({ // ... document: { actions: (prev, {schemaType}) => { // Voeg een custom "Update and timestamp" actie toe if (schemaType === 'blogPost' || schemaType === 'page') { return prev.map((originalAction) => originalAction.action === 'publish' ? { ...originalAction, onHandle: async (args) => { // Update het `lastUpdated` veld voor publicatie args.patch({set: {lastUpdated: new Date().toISOString()}}) originalAction.onHandle?.(args) }, } : originalAction ) } return prev }, }, }) ``` #### B. Automatiseer de Scriptuitvoering Plan de scripts wekelijks in met een **Cron Job**: 1. **Host de scripts** op een betrouwbaar platform (Vercel Serverless Functions, AWS Lambda, een eigen server, etc.). 2. **Stel een Cron Job in** die een HTTP endpoint aanroept dat je script triggert. Bijvoorbeeld met: * Vercel: `vercel cron add` of via het dashboard. * AWS EventBridge + Lambda. * Een simpele `crontab -e` op een server: `0 0 * * 0 curl https://jouw-api.com/run-archive-script`. --- ### Samenvatting en Aanbevelingen 1. **Twee datasets:** Gebruik `production` en `archive` voor een veilige scheiding. 2. **Soft-Delete eerst:** Begin met het markeren van content als gearchiveerd (`isArchived: true`) voordat je deze definitief verwijdert. Dit geeft een grace period. 3. **Logging:** Zorg voor uitgebreide logging in je scripts om het proces te kunnen auditen. 4. **Backup:** Ook al verwijder je data, zorg dat je een robuust backup-beleid hebt voor je Sanity project voor het allerergste scenario. 5. **Test grondig:** Voer deze scripts eerst uitgebreid uit op een `development` of `staging` dataset voordat je ze op `production` loslaat. Deze strategie is modulair, veilig en volledig geautomatiseerd. Het integreert naadloos met je bestaande Sanity workflow door gebruik te maken van de krachtige JavaScript client en planningstools van buitenaf.