Auto-Publishing Scheduled Posts with GitHub Actions

import { readdir, readFile, appendFile } from "node:fs/promises";
import { join } from "node:path";

const TZ = "Asia/Jakarta";
const MARGIN_MS = 15 * 60 * 1000;
const TIMESTAMP_FILE = ".last-deploy-timestamp";

const ROOT_DIRS = ["src/data/blog", "src/data/notes", "src/data/links"];

interface Frontmatter {
  pubDatetime: string | null;
  draft: boolean;
}

function formatYMDInTZ(date: Date, timeZone: string): string {
  return new Intl.DateTimeFormat("en-CA", {
    timeZone,
    year: "numeric",
    month: "2-digit",
    day: "2-digit",
  }).format(date);
}

function parseFrontmatter(raw: string): Frontmatter | null {
  if (!raw.startsWith("---")) return null;

  const lines = raw.split(/\r?\n/);
  if (lines[0].trim() !== "---") return null;

  let end = -1;
  for (let i = 1; i < lines.length; i++) {
    if (lines[i].trim() === "---") {
      end = i;
      break;
    }
  }
  if (end === -1) return null;

  const fmLines = lines.slice(1, end);

  const getScalar = (key: string): string | null => {
    const re = new RegExp(`^\\s*${key}\\s*:\\s*(.+?)\\s*$`);
    for (const line of fmLines) {
      const m = line.match(re);
      if (m) {
        let v = m[1].trim();
        if (
          (v.startsWith('"') && v.endsWith('"')) ||
          (v.startsWith("'") && v.endsWith("'"))
        ) {
          v = v.slice(1, -1);
        }
        return v;
      }
    }
    return null;
  };

  const pubDatetime = getScalar("pubDatetime");
  const draftRaw = getScalar("draft");
  const draft = draftRaw ? draftRaw.toLowerCase() === "true" : false;

  return { pubDatetime, draft };
}

async function listMarkdownFiles(dir: string): Promise<string[]> {
  let entries;
  try {
    entries = await readdir(dir, { withFileTypes: true });
  } catch {
    return [];
  }
  return entries
    .filter(e => e.isFile() && e.name.endsWith(".md"))
    .map(e => join(dir, e.name));
}

async function getLastDeployTime(): Promise<Date | null> {
  try {
    const raw = await readFile(TIMESTAMP_FILE, "utf8");
    const ts = new Date(raw.trim());
    if (!Number.isNaN(ts.getTime())) return ts;
  } catch {
    // no cached timestamp
  }
  return null;
}

async function setOutput(key: string, value: string): Promise<void> {
  const outPath = process.env.GITHUB_OUTPUT;
  const line = `${key}=${value}\n`;
  if (outPath) {
    await appendFile(outPath, line);
    return;
  }
  process.stdout.write(line);
}

async function main() {
  const now = new Date();
  const lastDeploy = await getLastDeployTime();

  const allFiles = (
    await Promise.all(ROOT_DIRS.map(d => listMarkdownFiles(d)))
  ).flat();

  const due: string[] = [];

  for (const file of allFiles) {
    const raw = await readFile(file, "utf8");
    const fm = parseFrontmatter(raw);
    if (!fm || !fm.pubDatetime) continue;
    if (fm.draft) continue;

    const pub = new Date(fm.pubDatetime);
    if (Number.isNaN(pub.getTime())) continue;

    const effectivePub = pub.getTime() - MARGIN_MS;
    const publishableNow = now.getTime() >= effectivePub;

    if (!publishableNow) continue;

    if (lastDeploy) {
      const isNewSinceLastDeploy = pub.getTime() > lastDeploy.getTime();
      if (isNewSinceLastDeploy) {
        due.push(file);
      }
    } else {
      due.push(file);
    }
  }

  const shouldDeploy = due.length > 0;

  await setOutput("should_deploy", shouldDeploy ? "true" : "false");
  await setOutput("due_count", String(due.length));
  await setOutput("due_files", due.join(","));

  console.log(
    [
      `Now (UTC): ${now.toISOString()}`,
      `Today (Asia/Jakarta): ${formatYMDInTZ(now, TZ)}`,
      `Last deploy: ${lastDeploy ? lastDeploy.toISOString() : "(none, first run)"}`,
      `Posts due since last deploy: ${due.length}`,
      ...(due.length ? due.map(f => `  - ${f}`) : []),
    ].join("\n")
  );
}

main().catch(err => {
  console.error(err);
  process.exit(1);
});

name: Deploy Astro Site

on:
  workflow_dispatch:
  push:
    branches:
      - master
  schedule:
    # 12:00 Asia/Jakarta (UTC+7) == 05:00 UTC
    - cron: "0 5 * * *"

concurrency:
  group: deploy-astro-site
  cancel-in-progress: false

jobs:
  check_scheduled_posts:
    name: Check scheduled posts
    runs-on: ubuntu-latest
    outputs:
      should_deploy: ${{ steps.check.outputs.should_deploy }}
      due_count: ${{ steps.check.outputs.due_count }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
          bun-version: latest

      - name: Restore last deploy timestamp
        uses: actions/cache/restore@v4
        with:
          path: .last-deploy-timestamp
          key: last-deploy-ts-
          restore-keys: |
            last-deploy-ts-

      - id: check
        name: Check for posts due since last deploy
        run: bun run scripts/check-scheduled-posts.ts

  deploy:
    name: Build and deploy
    runs-on: ubuntu-latest
    needs: [check_scheduled_posts]
    if: >-
      ${{ github.event_name != 'schedule' ||
          needs.check_scheduled_posts.outputs.should_deploy == 'true' }}
    steps:
      - name: Checkout
        uses: actions/checkout@v4

      - name: Setup Bun
        uses: oven-sh/setup-bun@v1
        with:
          bun-version: latest

      - name: Install Dependencies
        run: bun install

      - name: Build Astro Site
        run: bun run build

      # Replace this with your own deploy step
      - name: Deploy to Server
        run: echo "Deploy your site here"

      - name: Save deploy timestamp
        run: date -u +"%Y-%m-%dT%H:%M:%SZ" > .last-deploy-timestamp

      - name: Cache deploy timestamp
        uses: actions/cache/save@v4
        with:
          path: .last-deploy-timestamp
          key: last-deploy-ts-${{ github.run_id }}