📢 Optimiser le SEO de son portfolio avec l'automatisation de la publication sur Facebook et LinkedIn (Next.js + Vercel Cron)

// /app/api/refresh-facebook-token/route.ts
import { NextResponse } from "next/server";
import { getAll, has, get } from '@vercel/edge-config';

// On récupère les identifiants de l'app Facebook
const facebook_app_id = process.env.FACEBOOK_APP_ID!;
const facebook_app_secret = process.env.FACEBOOK_APP_SECRET!;

// Route GET appelée par une tâche cron Vercel
export async function GET() {
    try {
        // Vérifie si un token existe déjà dans l'Edge Config
        const hasFacebookToken = await has('facebook_token');

        if (hasFacebookToken) {
            const oldToken = await get('facebook_token') as string;

            // On tente de renouveler le token
            const result = await updateFacebookToken(oldToken);

            if (result?.success) {
                return NextResponse.json({
                    facebookToken: result.newToken,
                    status: 'success',
                    message: 'Token Facebook renouvelé.'
                });
            } else {
                return NextResponse.json({
                    status: 'error',
                    message: 'Échec du renouvellement du token Facebook.'
                }, { status: 500 });
            }
        }

        // Aucun token Facebook trouvé → retour d'état
        const configItems = await getAll();
        return NextResponse.json({
            configItems,
            status: 'ok',
            message: 'Aucun token Facebook à rafraîchir.'
        });
    } catch (err: any) {
        console.error('Erreur lors du rafraîchissement du token :', err);
        return NextResponse.json({
            status: 'error',
            message: 'Erreur serveur lors de la tentative de rafraîchissement.'
        }, { status: 500 });
    }
}

// Fonction qui appelle l'API Facebook pour renouveler le token
async function updateFacebookToken(oldToken: string): Promise<{ success: boolean, newToken?: string }> {
    try {
        // Appel à Facebook pour échanger le token
        const res = await fetch(`https://graph.facebook.com/v21.0/oauth/access_token?grant_type=fb_exchange_token&client_id=${facebook_app_id}&client_secret=${facebook_app_secret}&fb_exchange_token=${oldToken}`);
        const data = await res.json();

        if (!data.access_token) {
            console.error('Réponse invalide de Facebook :', data);
            return { success: false };
        }

        // Mise à jour dans l’Edge Config
        const updateRes = await fetch(
            `https://api.vercel.com/v1/edge-config/${process.env.VERCEL_EDGE_ID}/items?teamId=${process.env.VERCEL_TEAM_ID}`,
            {
                method: 'PATCH',
                headers: {
                    Authorization: `Bearer ${process.env.VERCEL_API_TOKEN}`,
                    'Content-Type': 'application/json',
                },
                body: JSON.stringify({
                    items: [
                        {
                            operation: 'update',
                            key: 'facebook_token',
                            value: data.access_token,
                        },
                    ],
                }),
            }
        );

        const result = await updateRes.json();

        if (updateRes.ok) {
            return { success: true, newToken: data.access_token };
        } else {
            console.error('Échec de la mise à jour Vercel Edge:', result);
            return { success: false };
        }
    } catch (error) {
        console.error('Erreur dans updateFacebookToken:', error);
        return { success: false };
    }
}

import { baseURL } from '@/app/resources';
import { getPosts } from '@/app/utils/serverActions';
import { NextResponse } from 'next/server';
import { postToFacebook } from './postToFacebook';
import { postToLinkedIn } from './postToLinkedIn';
import { get } from '@vercel/edge-config';
export const revalidate = 0;
// Environnement d'exécution
const env = process.env.NODE_ENV;
// Clé Edge Config pour les slugs partagés
const SHARED_ARTICLES_KEY = 'sharedArticlesSlugs';
const STORED_SLUG_LENGTH = 40
/**
 * Gère la requête GET pour la publication automatique d'articles.
 * Appelé par une tâche planifiée (cron job) via Vercel Cron Jobs.
 */
export async function GET(req: Request) {
    // Vérification de sécurité (jeton secret requis en production)
    if (!(env === 'development') && req.headers.get('Authorization') !== `Bearer ${process.env.CRON_SECRET}`) {
        console.error("🚫 Accès non autorisé.");
        return NextResponse.json({ status: 'Unauthorized', code: 401, message: 'Accès non autorisé.' });
    }

    // Vérification du jour de la semaine (désactivé le week-end et mercredi)
    const today = new Date();
    const dayOfWeek = today.getDay();
    if (dayOfWeek === 0 || dayOfWeek === 6 || dayOfWeek === 3) {
        const dayName = today.toLocaleDateString('fr-FR', { weekday: 'long' });
        console.log(`⏱️ Partage désactivé aujourd'hui (${dayName}).`);
        return NextResponse.json({ status: 'skipped', message: `Partage désactivé le week-end et le mercredi. Actuellement, c'est ${dayName}.` });
    }

    // Récupère les 10 derniers articles publiés
    const articles = await getPosts({ limit: 10 });
    // Récupère les slugs des articles déjà partagés depuis Edge Config
    let sharedArticlesSlugs: string[] = (await get(SHARED_ARTICLES_KEY)) || [];

    // Filtre les articles déjà partagés
    const unsharedArticles = articles.filter(post => !sharedArticlesSlugs.includes(post.slug));

    // Trie les articles non partagés par date de publication (du plus ancien au plus récent)
    unsharedArticles.sort((a, b) => {
        const dateA = a.metadata.publishedAt ? new Date(a.metadata.publishedAt).getTime() : 0;
        const dateB = b.metadata.publishedAt ? new Date(b.metadata.publishedAt).getTime() : 0;
        return dateA - dateB;
    });

    // Traite et partage le premier article éligible (le plus ancien non partagé)
    if (unsharedArticles.length > 0) {
        const articleToShare = unsharedArticles[0]!; // Prend le plus ancien article non partagé

        if (articleToShare.metadata.publishedAt) {
            // Prépare les données pour le partage
            const postData = {
                title: articleToShare.metadata.title as string,
                description: articleToShare.metadata.description as string,
                url: `${baseURL}/blog/${articleToShare.slug}`
            };

            try {
                // Publie l'article sur les plateformes sociales en parallèle
                console.log("publie ! ", articleToShare.slug)
                await Promise.all([
                    postToFacebook(postData),
                    postToLinkedIn(postData)
                ]);
                console.log(`✅ Article "${articleToShare.slug}" partagé.`);

                // Met à jour la liste locale des slugs partagés
                const arrayLength = sharedArticlesSlugs.unshift(articleToShare.slug);
                // Garde les 10 derniers slugs partagés
                if (arrayLength > STORED_SLUG_LENGTH) {
                    sharedArticlesSlugs = sharedArticlesSlugs.slice(0, STORED_SLUG_LENGTH);
                }

                // Met à jour Edge Config avec la nouvelle liste
                const updateRes = await fetch(
                    `https://api.vercel.com/v1/edge-config/${process.env.VERCEL_EDGE_ID}/items?teamId=${process.env.VERCEL_TEAM_ID}`,
                    {
                        method: 'PATCH',
                        headers: {
                            Authorization: `Bearer ${process.env.VERCEL_API_TOKEN}`,
                            'Content-Type': 'application/json',
                        },
                        body: JSON.stringify({
                            items: [
                                {
                                    operation: 'update',
                                    key: SHARED_ARTICLES_KEY,
                                    value: sharedArticlesSlugs,
                                },
                            ],
                        }),
                    }
                );

                // Gère l'échec de la mise à jour Edge Config
                if (!updateRes.ok) {
                    const errorResult = await updateRes.json();
                    console.error("❌ Échec mise à jour Edge Config:", errorResult);
                    return NextResponse.json({ status: 'error', message: "Échec mise à jour Edge Config après partage." });
                }
                console.log(updateRes)
                return NextResponse.json({ status: 'done', message: `Article "${articleToShare.slug}" partagé et Edge Config mis à jour.`, sharedCount: 1, unsharedArticles });

            } catch (socialError) {
                // Gère les erreurs de partage social
                console.error(`❌ Échec partage article "${articleToShare.slug}":`, socialError);
                return NextResponse.json({ status: 'error', message: `Erreur lors du partage social pour l'article "${articleToShare.slug}".` });
            }
        } else {
            console.log(`⏭️ L'article "${articleToShare.slug}" n'est pas publié.`);
            return NextResponse.json({
                status: 'skipped',
                message: `L'article "${articleToShare.slug}" n'est pas éligible au partage (non publié).`
            });
        }
    }

    // Aucun article éligible trouvé
    console.log('ℹ️ Aucun article éligible trouvé à partager.');
    return NextResponse.json({ status: 'no_articles', message: 'Aucun article éligible trouvé à partager.' });
}

import { get } from '@vercel/edge-config';
import ogs from 'open-graph-scraper'; // Importation pour scraper les métadonnées Open Graph

/**
 * Publie un article sur LinkedIn en tant que post UGC.
 * Utilise les métadonnées Open Graph de l'URL de l'article pour un aperçu riche.
 *
 * @param article Un objet contenant les détails de l'article (titre, description, URL).
 * @returns {Promise<void>} Une promesse qui se résout en cas de succès, ou rejette une erreur détaillée.
 */
export async function postToLinkedIn(article: { title: string; description: string; url: string }): Promise<void> {
    // Récupération du token d'accès LinkedIn.
    const accessToken = (await get('linkedin_token')) as string;
    if (!accessToken) {
        throw new Error('Erreur critique: Le token d\'accès LinkedIn est manquant.');
    }

    // Récupération de l'URN de l'auteur.
    const personURN = process.env.LINKEDIN_AUTHOR_URN;
    if (!personURN) {
        throw new Error('Erreur critique: L\'URN de l\'auteur LinkedIn est manquant.');
    }

    try {
        // Extraction des métadonnées Open Graph.
        const ogResult = await ogs({ url: article.url });
        const ogData = ogResult.result;

        console.log('Données OpenGraph brutes récupérées :', ogData); // Pour débogage

        const ogTitle = ogData.ogTitle || article.title;
        const ogDescription = ogData.ogDescription || article.description;
        let ogImage: string | undefined;

        // Logique d'extraction de l'URL de l'image Open Graph plus robuste
        if (ogData.ogImage) {
            if (Array.isArray(ogData.ogImage)) {
                // Cherche la première image valide dans le tableau
                const firstImage = ogData.ogImage.find(img => typeof img === 'object' && img !== null && 'url' in img);
                if (firstImage) {
                    ogImage = (firstImage as { url: string }).url;
                }
            } else if (typeof ogData.ogImage === 'object' && ogData.ogImage !== null && 'url' in ogData.ogImage) {
                // Gère un objet image unique
                ogImage = (ogData.ogImage as { url: string }).url;
            } else if (typeof ogData.ogImage === 'string') {
                // Gère une URL d'image directe
                ogImage = ogData.ogImage;
            }
        }

        console.log('URL de l\'image OpenGraph extraite :', ogImage); // Pour débogage

        // Construction du payload JSON pour le post LinkedIn.
        const postBody: any = {
            author: personURN,
            lifecycleState: 'PUBLISHED',
            specificContent: {
                'com.linkedin.ugc.ShareContent': {
                    shareCommentary: {
                        text: ogTitle
                    },
                    shareMediaCategory: 'ARTICLE',
                    media: [
                        {
                            status: 'READY',
                            description: {
                                text: ogDescription
                            },
                            originalUrl: article.url,
                            title: {
                                text: ogTitle
                            },
                        }
                    ]
                }
            },
            visibility: {
                'com.linkedin.ugc.MemberNetworkVisibility': 'PUBLIC'
            }
        };

        // Ajoute la miniature si une URL d'image valide a été trouvée
        if (ogImage && ogImage.startsWith('http')) { // Simple validation pour s'assurer que c'est une URL HTTP(S)
            (postBody.specificContent['com.linkedin.ugc.ShareContent'].media[0] as any).thumbnails = [
                { resolvedUrl: ogImage }
            ];
        } else {
            console.warn('⚠️ Aucune URL d\'image OpenGraph valide trouvée ou extraite. Le post LinkedIn n\'aura pas de miniature.');
        }

        // Envoi de la requête HTTP POST à l'API LinkedIn.
        const res = await fetch('https://api.linkedin.com/v2/ugcPosts', {
            method: 'POST',
            headers: {
                Authorization: `Bearer ${accessToken}`,
                'X-Restli-Protocol-Version': '2.0.0',
                'Content-Type': 'application/json'
            },
            body: JSON.stringify(postBody)
        });

        // Gestion de la réponse de l'API.
        if (!res.ok) {
            const errorText = await res.text();
            const errorMessage = `❌ Échec publication LinkedIn: Statut ${res.status} - ${res.statusText}. Détails: ${errorText}`;
            console.error(errorMessage);
            throw new Error(errorMessage);
        }

        console.log('🎉 Article posté sur LinkedIn avec succès !');
    } catch (error) {
        console.error('⚠️ Erreur lors de la publication sur LinkedIn:', error);
        throw error;
    }
}

import { get } from '@vercel/edge-config';

/**
 * Publie un article donné sur une page Facebook configurée.
 * Récupère le token d'accès de la page et l'ID de la page depuis les sources sécurisées (Edge Config et variables d'environnement).
 * Interagit avec l'API Graph de Facebook pour créer un nouveau post.
 *
 * @param article Un objet contenant les informations essentielles de l'article à partager.
 * Ex: { title: "Mon Super Article", description: "Une description captivante", url: "https://monblog.com/article-slug" }
 * @returns {Promise<void>} Une promesse qui se résout sans valeur en cas de succès, ou rejette une erreur détaillée en cas d'échec.
 */
export async function postToFacebook(article: { title: string; description: string; url: string }): Promise<void> {
    // === Section 1 : Récupération des Informations d'Authentification et de Configuration ===

    // 1. Récupération du token d'accès Facebook depuis Vercel Edge Config.
    // C'est la méthode recommandée pour les secrets qui peuvent changer ou être gérés dynamiquement.
    const accessToken = await get('facebook_token') as string;

    // Vérification critique : S'assurer que le token d'accès est disponible.
    // Sans ce token, aucune requête API ne peut être authentifiée.
    if (!accessToken) {
        const errorMessage = 'Erreur critique: Le token d\'accès Facebook est manquant dans Edge Config. Impossible de publier.';
        console.error(errorMessage);
        throw new Error(errorMessage); // Lance une erreur pour stopper l'exécution et signaler le problème.
    }

    // 2. Récupération de l'ID de la page Facebook depuis les variables d'environnement.
    // Cet ID est spécifique à la page où le post doit être publié.
    const pageId = process.env.FACEBOOK_PAGE_ID;

    // Vérification critique : S'assurer que l'ID de la page est défini.
    if (!pageId) {
        const errorMessage = 'Erreur critique: L\'ID de la page Facebook (FACEBOOK_PAGE_ID) est manquant dans les variables d\'environnement. Impossible de publier.';
        console.error(errorMessage);
        throw new Error(errorMessage);
    }

    // URL de base pour l'API Graph de Facebook pour la publication sur le fil d'actualité d'une page.
    const apiUrl = `https://graph.facebook.com/${pageId}/feed`;

    // === Section 2 : Préparation des Données du Post ===

    // Préparation des paramètres de la requête.
    // URLSearchParams est utilisé pour construire une chaîne de requête URL sécurisée et correctement encodée.
    const params = new URLSearchParams({
        // Le message principal du post, combinant le titre et la description de l'article avec un double saut de ligne pour la lisibilité.
        message: `${article.title}\n\n${article.description}`,
        // L'URL de l'article qui sera partagée. Facebook va souvent extraire les métadonnées Open Graph de cette URL
        // pour générer un aperçu riche (titre, image, description) directement dans le post.
        link: article.url,
        // Le token d'accès est inclus en tant que paramètre de requête pour l'authentification.
        access_token: accessToken
    });

    // === Section 3 : Exécution de la Requête API et Gestion des Erreurs ===

    try {
        // Envoi de la requête HTTP POST à l'API Graph de Facebook.
        // Les paramètres sont ajoutés directement à l'URL.
        const res = await fetch(`${apiUrl}?${params.toString()}`, {
            method: 'POST',
            // Spécifie le type de contenu de la requête. Important pour que l'API interprète correctement les données.
            headers: {
                'Content-Type': 'application/x-www-form-urlencoded',
            },
        });

        // 5. Gestion de la réponse de l'API.
        // Si la réponse HTTP n'est pas dans la plage 2xx (e.g., 400 Bad Request, 500 Internal Server Error),
        // cela indique une erreur de l'API Facebook.
        if (!res.ok) {
            const errorText = await res.text(); // Tente de récupérer le corps de la réponse d'erreur pour des détails.
            const errorMessage = `❌ Échec de la publication Facebook: Statut ${res.status} - ${res.statusText}. Détails: ${errorText}`;
            console.error(errorMessage);
            throw new Error(errorMessage); // Relance une erreur avec des informations complètes.
        }

        // Si la publication est réussie, l'API retourne un objet JSON contenant souvent l'ID du post.
        const result = await res.json();
        console.log(`🎉 Article posté sur Facebook avec succès. ID du post: ${result.id}`);
        // `void` signifie que la fonction n'a pas besoin de retourner une valeur en cas de succès.
    } catch (error) {
        // Capture les erreurs qui peuvent survenir pendant l'appel `fetch` (ex: problèmes réseau, CORS).
        console.error('⚠️ Erreur inattendue lors de l\'envoi de la requête à Facebook:', error);
        throw error; // Relance l'erreur pour qu'elle puisse être gérée par la fonction appelante (dans `route.ts`).
    }
}

{
    "crons": [
        {
            "path": "/api/cron/indexNow",
            "schedule": "0 0 * * *"
        },
        {
            "path": "/api/cron/social-share",
            "schedule": "0 7 * * *"
        },
        {
            "path": "/api/cron/refresh-facebook-token",
            "schedule": "0 4 20 * *"
        }
    ]
}