Update README with Latest Articles Using GitHub Actions and Deno 2

name: Update readme articles

on:
  # Add a schedule to run the job every month at 0:00 UTC
  schedule:
    - cron: '0 0 1 * *'

  # Allow running this workflow manually
  workflow_dispatch:

jobs:
  update-readme-articles:
    runs-on: ubuntu-latest

    steps:
      - name: Checkout sources
        uses: actions/checkout@v4

      - name: Setup Deno environment
        uses: denoland/setup-deno@v2
        with:
          deno-version: v2.x

      - name: Run script
        run: |
          deno run -A scripts/update-readme-articles.ts

      - name: Commit and push changes
        env:
          # This is necessary in order to push a commit to the main branch
          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
        run: |
          git config --local user.email "github-actions[bot]@users.noreply.github.com"
          git config --local user.name "github-actions[bot]"
          git add .
          if [[ -n "$(git status --porcelain)" ]]; then
            git commit -m ":wrench: Update readme articles"
            git push origin main
          fi

# Hi 👋, I'm Joan Roucoux

## About me 💬

...

## My latest articles 📝

<!-- ARTICLES:START -->
<!-- ARTICLES:END -->

🚀 This section is updated by GitHub Actions Workflows ❤️

...

deno init

...
<!-- ARTICLES:START -->
- [Update README with Latest Articles Using GitHub Actions](https://dev.to/joanroucoux/update-readme-with-latest-articles-using-github-actions-41m3)
- [Building a Marvel Search Application with Qwik](https://dev.to/joanroucoux/building-a-marvel-search-application-with-qwik-ll7)
<!-- ARTICLES:END -->
...

// types.ts
interface User {
  name: string;
  username: string;
  twitter_username: string | null;
  github_username: string;
  user_id: number;
  website_url: string;
  profile_image: string;
  profile_image_90: string;
}

export interface Article {
  type_of: string;
  id: number;
  title: string;
  description: string;
  readable_publish_date: string;
  slug: string;
  path: string;
  url: string;
  comments_count: number;
  public_reactions_count: number;
  collection_id: number | null;
  published_timestamp: string;
  positive_reactions_count: number;
  cover_image: string | null;
  social_image: string;
  canonical_url: string;
  created_at: string;
  edited_at: string;
  crossposted_at: string | null;
  published_at: string;
  last_comment_at: string;
  reading_time_minutes: number;
  tag_list: string[];
  tags: string;
  user: User;
}

export interface ArticlePreview {
  title: string;
  url: string;
}

// update-readme-articles.ts
import * as fs from 'node:fs/promises';
import path from 'node:path';
import { Article, ArticlePreview } from './types.ts';

const DEV_TO_API_BASE_URL = 'https://dev.to/api';
const USERNAME = 'joanroucoux';

const main = async (): Promise<void> => {
  // Read the original file content
  const filePath = '../README.md';
  const markdown = await readFile(filePath);

  // Proceed only if the file was read successfully
  if (markdown) {
    // Fetch latest articles
    const articles = await fetchArticles(USERNAME);

    // Generate new content
    const newContent = generateArticlesContent(articles);

    // Replace content between markers
    const START_MARKER = '<!-- ARTICLES:START -->';
    const END_MARKER = '<!-- ARTICLES:END -->';
    const updatedMarkdown = replaceContentBetweenMarkers(
      markdown,
      START_MARKER,
      END_MARKER,
      newContent
    );

    // Save the updated file
    await saveFile(filePath, updatedMarkdown);
  }
};

// Fetch latest articles
const fetchArticles = async (
  username: string,
  page: number = 1,
  perPage: number = 5
): Promise<ArticlePreview[]> => {
  const response = await fetch(
    `${DEV_TO_API_BASE_URL}/articles?username=${username}&page=${page}&per_page=${perPage}`
  );
  const data: Article[] = await response.json();
  return data?.map((article: Article) => ({
    title: article.title,
    url: article.url,
  }));
};

// Generate markdown from articles
const generateArticlesContent = (articles: ArticlePreview[]): string => {
  let markdown = '';

  articles?.forEach((article) => {
    markdown += `- [${article.title}](${article.url})\n`;
  });

  return markdown;
};

// Read file
const readFile = async (filePath: string): Promise<string | null> => {
  try {
    const absolutePath = path.resolve(import.meta.dirname, filePath);
    console.log('Reading file from:', absolutePath);
    return await fs.readFile(absolutePath, 'utf8');
  } catch (err) {
    console.error('Error reading file:', err);
    return null;
  }
};

// Generate updated markdown
const replaceContentBetweenMarkers = (
  markdown: string,
  startMarker: string,
  endMarker: string,
  newContent: string
): string => {
  const regex = new RegExp(`(${startMarker})([\\s\\S]*?)(${endMarker})`, 'g');
  return markdown.replace(regex, `$1\n${newContent}$3`);
};

// Save file
const saveFile = async (filePath: string, content: string): Promise<void> => {
  try {
    const absolutePath = path.resolve(import.meta.dirname, filePath);
    await fs.writeFile(absolutePath, content, 'utf8');
    console.log('File has been saved successfully!');
  } catch (err) {
    console.error('Error saving file:', err);
  }
};

main();