feat: add server side atproto blog apis

modules/standard-site-sync.ts

@@ -0,0 +1,134 @@
+import { readFileSync } from 'node:fs'
+import { createHash } from 'node:crypto'
+import { defineNuxtModule, useNuxt, createResolver } from 'nuxt/kit'
+import { safeParse } from 'valibot'
+import * as site from '../shared/types/lexicons/site'
+import { BlogPostSchema } from '../shared/schemas/blog'
+import { NPMX_SITE } from '../shared/utils/constants'
+import { parseBasicFrontmatter } from '../shared/utils/parse-basic-frontmatter'
+import { TID } from '@atproto/common'
+import { Client } from '@atproto/lex'
+
+const syncedDocuments = new Map<string, string>()
+const CLOCK_ID_THREE = 3
+const DATE_TO_MICROSECONDS = 1000
+
+// TODO: Currently logging quite a lot, can remove some later if we want
+export default defineNuxtModule({
+  meta: { name: 'standard-site-sync' },
+  async setup() {
+    const nuxt = useNuxt()
+    const { resolve } = createResolver(import.meta.url)
+    const contentDir = resolve('../app/pages/blog')
+
+    // Authentication with PDS using an app password
+    const pdsUrl = process.env.NPMX_PDS_URL
+    if (!pdsUrl) {
+      console.warn('[standard-site-sync] NPMX_PDS_URL not set, skipping sync')
+      return
+    }
+    // Instantiate a single new client instance that is reused for every file
+    const client = new Client(pdsUrl)
+
+    if (nuxt.options._prepare) return
+
+    nuxt.hook('build:before', async () => {
+      const { glob } = await import('tinyglobby')
+      const files: string[] = await glob(`${contentDir}/**/*.md`)
+
+      // INFO: Arbitrarily chosen concurrency limit, can be changed if needed
+      const concurrencyLimit = 5
+      for (let i = 0; i < files.length; i += concurrencyLimit) {
+        const batch = files.slice(i, i + concurrencyLimit)
+        // Process files in parallel
+        await Promise.all(
+          batch.map(file =>
+            syncFile(file, NPMX_SITE, client).catch(error =>
+              console.error(`[standard-site-sync] Error in ${file}:` + error),
+            ),
+          ),
+        )
+      }
+    })
+
+    nuxt.hook('builder:watch', async (event, path) => {
+      if (!path.endsWith('.md')) return
+
+      // Ignore deleted files
+      if (event === 'unlink') {
+        console.log(`[standard-site-sync] File deleted: ${path}`)
+        return
+      }
+
+      // Process add/change events only
+      await syncFile(resolve(nuxt.options.rootDir, path), NPMX_SITE, client).catch(err =>
+        console.error(`[standard-site-sync] Failed ${path}:`, err),
+      )
+    })
+  },
+})
+
+/*
+ * INFO: Loads record to atproto and ensures uniqueness by checking the date the article is published
+ * publishedAt is an id that does not change
+ * Atomicity is enforced with upsert using publishedAt so we always update existing records instead of creating new ones
+ * Clock id(3) provides a deterministic ID
+ * WARN: DOES NOT CATCH ERRORS, THIS MUST BE HANDLED
+ */
+const syncFile = async (filePath: string, siteUrl: string, client: Client) => {
+  const fileContent = readFileSync(filePath, 'utf-8')
+  const frontmatter = parseBasicFrontmatter(fileContent)
+
+  // Schema expects 'path' & frontmatter provides 'slug'
+  const normalizedFrontmatter = {
+    ...frontmatter,
+    path: typeof frontmatter.slug === 'string' ? `/blog/${frontmatter.slug}` : frontmatter.path,
+  }
+
+  const result = safeParse(BlogPostSchema, normalizedFrontmatter)
+  if (!result.success) {
+    console.warn(`[standard-site-sync] Validation failed for ${filePath}`, result.issues)
+    return
+  }
+
+  const data = result.output
+
+  // filter drafts
+  if (data.draft) {
+    if (process.env.DEBUG === 'true') {
+      console.debug(`[standard-site-sync] Skipping draft: ${data.path}`)
+    }
+    return
+  }
+
+  // Keys are sorted to provide a more stable hash
+  const hash = createHash('sha256')
+    .update(JSON.stringify(data, Object.keys(data).sort()))
+    .digest('hex')
+
+  if (syncedDocuments.get(data.path) === hash) {
+    return
+  }
+
+  const document = site.standard.document.$build({
+    site: siteUrl as `${string}:${string}`,
+    path: data.path,
+    title: data.title,
+    description: data.description ?? data.excerpt,
+    tags: data.tags,
+    // This can be extended to update the site.standard.document .updatedAt if it is changed and use the posts date here
+    publishedAt: new Date(data.date).toISOString(),
+  })
+
+  const dateInMicroSeconds = new Date(result.output.date).getTime() * DATE_TO_MICROSECONDS
+
+  // Clock id(3) needs to be the same everytime to get the same TID from a timestamp
+  const tid = TID.fromTime(dateInMicroSeconds, CLOCK_ID_THREE)
+
+  // client.put is async and needs to be awaited
+  await client.put(site.standard.document, document, {
+    rkey: tid.str,
+  })
+
+  syncedDocuments.set(data.path, hash)
+}

package.json

@@ -25,7 +25,7 @@
     "npmx-connector": "pnpm --filter npmx-connector dev",
     "generate-pwa-icons": "pwa-assets-generator",
     "preview": "nuxt preview",
-    "postinstall": "nuxt prepare && simple-git-hooks && pnpm generate:lexicons",
+    "postinstall": "pnpm generate:lexicons && nuxt prepare && simple-git-hooks",
     "generate:fixtures": "node scripts/generate-fixtures.ts",
     "generate:lexicons": "lex build --lexicons lexicons --out shared/types/lexicons --clear",
     "test": "vite test",
@@ -34,12 +34,13 @@
     "test:browser:ui": "pnpm build:playwright && pnpm test:browser:prebuilt --ui",
     "test:browser:update": "pnpm build:playwright && pnpm test:browser:prebuilt --update-snapshots",
     "test:nuxt": "vite test --project nuxt",
-    "test:types": "nuxt prepare && vue-tsc -b --noEmit && pnpm --filter npmx-connector test:types",
+    "test:types": "pnpm generate:lexicons && nuxt prepare && vue-tsc -b --noEmit && pnpm --filter npmx-connector test:types",
     "test:unit": "vite test --project unit",
     "start:playwright:webserver": "NODE_ENV=test pnpm preview --port 5678"
   },
   "dependencies": {
     "@atproto/api": "^0.18.17",
+    "@atproto/common": "0.5.10",
     "@atproto/lex": "0.0.13",
     "@atproto/oauth-client-node": "^0.3.15",
     "@deno/doc": "jsr:^0.189.1",
@@ -75,6 +76,7 @@
     "defu": "6.1.4",
     "fast-npm-meta": "1.0.0",
     "focus-trap": "^7.8.0",
+    "tinyglobby": "0.2.15",
     "marked": "17.0.1",
     "module-replacements": "2.11.0",
     "nuxt": "4.3.0",

server/api/atproto/author-profiles.get.ts

@@ -0,0 +1,87 @@
+import * as v from 'valibot'
+import { CACHE_MAX_AGE_ONE_DAY, BLUESKY_API } from '#shared/utils/constants'
+import { AuthorSchema } from '#shared/schemas/blog'
+import type { Author, ResolvedAuthor } from '#shared/schemas/blog'
+
+type ProfilesResponse = {
+  profiles: Array<{
+    did: string
+    handle: string
+    displayName?: string
+    avatar?: string
+  }>
+}
+
+export default defineCachedEventHandler(
+  async event => {
+    const query = getQuery(event)
+    const authorsParam = query.authors
+
+    if (!authorsParam || typeof authorsParam !== 'string') {
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'authors query parameter is required (JSON array)',
+      })
+    }
+
+    let authors: Author[]
+    try {
+      const parsed = JSON.parse(authorsParam)
+      authors = v.parse(v.array(AuthorSchema), parsed)
+    } catch (error) {
+      if (error instanceof v.ValiError) {
+        throw createError({
+          statusCode: 400,
+          statusMessage: `Invalid authors format: ${error.message}`,
+        })
+      }
+      throw createError({
+        statusCode: 400,
+        statusMessage: 'authors must be valid JSON',
+      })
+    }
+
+    if (!Array.isArray(authors) || authors.length === 0) {
+      return { authors: [] }
+    }
+
+    const handles = authors.filter(a => a.blueskyHandle).map(a => a.blueskyHandle as string)
+
+    if (handles.length === 0) {
+      return {
+        authors: authors.map(author => ({
+          ...author,
+          avatar: null,
+          profileUrl: null,
+        })),
+      }
+    }
+
+    const response = await $fetch<ProfilesResponse>(`${BLUESKY_API}app.bsky.actor.getProfiles`, {
+      query: { actors: handles },
+    }).catch(() => ({ profiles: [] }))
+
+    const avatarMap = new Map<string, string>()
+    for (const profile of response.profiles) {
+      if (profile.avatar) {
+        avatarMap.set(profile.handle, profile.avatar)
+      }
+    }
+
+    const resolvedAuthors: ResolvedAuthor[] = authors.map(author => ({
+      ...author,
+      avatar: author.blueskyHandle ? avatarMap.get(author.blueskyHandle) || null : null,
+      profileUrl: author.blueskyHandle ? `https://bsky.app/profile/${author.blueskyHandle}` : null,
+    }))
+
+    return { authors: resolvedAuthors }
+  },
+  {
+    name: 'author-profiles',
+    maxAge: CACHE_MAX_AGE_ONE_DAY,
+    getKey: event => {
+      const { authors } = getQuery(event)
+      return `author-profiles:${authors ?? 'npmx.dev'}`
+    },
+  },
+)