@amulet-laboratories/rig-nuxt 0.2.0 → 0.3.1

package/src/runtime/composables/useProducts.ts

@@ -0,0 +1,55 @@
+export interface Product {
+  slug: string
+  name: string
+  brand: string
+  category: string
+  niche: string
+  tags: string[]
+  price_range: string
+  amazon: {
+    asin: string
+    url: string
+    commission_rate: string
+  }
+  alt_retailers?: {
+    name: string
+    url: string
+    commission_rate: string
+  }[]
+  rating: number
+  one_liner: string
+  image_url?: string
+  image_alt?: string
+  pros: string[]
+  cons: string[]
+  last_verified: string
+  status: string
+}
+
+const productCache = new Map<string, Product>()
+
+export function useProducts() {
+  const getProduct = async (slug: string): Promise<Product | null> => {
+    if (productCache.has(slug)) {
+      return productCache.get(slug)!
+    }
+
+    try {
+      const product = await $fetch<Product>(`/api/products/${slug}`)
+      productCache.set(slug, product)
+      return product
+    } catch {
+      return null
+    }
+  }
+
+  const getAllProducts = async (): Promise<Product[]> => {
+    try {
+      return await $fetch<Product[]>('/api/products')
+    } catch {
+      return []
+    }
+  }
+
+  return { getProduct, getAllProducts }
+}

package/src/runtime/composables/useStructuredData.ts

@@ -0,0 +1,110 @@
+export interface StructuredDataPage {
+  title: string
+  description: string
+  author?: string
+  publishedAt?: string
+  updatedAt?: string
+  featuredImage?: {
+    src: string
+    alt: string
+    width: number
+    height: number
+  }
+  schema?: string
+  rating?: number
+  price?: string
+  faq?: Array<{ question: string; answer: string }>
+}
+
+export const useStructuredData = (page: StructuredDataPage) => {
+  const { name: siteName, url: siteUrl } = useSiteConfig()
+  const route = useRoute()
+  const url = `${siteUrl}${route.path}`
+
+  const baseData: Record<string, unknown> = {
+    '@context': 'https://schema.org',
+    headline: page.title,
+    description: page.description,
+    url: url,
+    author: {
+      '@type': 'Organization',
+      name: page.author || siteName,
+    },
+    publisher: {
+      '@type': 'Organization',
+      name: siteName,
+      url: siteUrl,
+    },
+  }
+
+  if (page.featuredImage) {
+    baseData.image = {
+      '@type': 'ImageObject',
+      url: `${siteUrl}${page.featuredImage.src}`,
+      width: page.featuredImage.width,
+      height: page.featuredImage.height,
+    }
+  }
+
+  if (page.publishedAt) {
+    baseData.datePublished = page.publishedAt
+  }
+
+  if (page.updatedAt) {
+    baseData.dateModified = page.updatedAt
+  }
+
+  let schemaType = 'Article'
+
+  switch (page.schema) {
+    case 'Review':
+      schemaType = 'Review'
+      baseData.itemReviewed = {
+        '@type': 'Product',
+        name: page.title,
+      }
+      if (page.rating) {
+        baseData.reviewRating = {
+          '@type': 'Rating',
+          ratingValue: page.rating,
+          bestRating: 5,
+        }
+      }
+      break
+    case 'HowTo':
+      schemaType = 'HowTo'
+      baseData.name = page.title
+      break
+    default:
+      schemaType = 'Article'
+  }
+
+  baseData['@type'] = schemaType
+
+  const scripts: Array<{ type: string; innerHTML: string }> = [
+    {
+      type: 'application/ld+json',
+      innerHTML: JSON.stringify(baseData),
+    },
+  ]
+
+  if (page.faq?.length) {
+    scripts.push({
+      type: 'application/ld+json',
+      innerHTML: JSON.stringify({
+        '@context': 'https://schema.org',
+        '@type': 'FAQPage',
+        mainEntity: page.faq.map((item) => ({
+          '@type': 'Question',
+          name: item.question,
+          acceptedAnswer: {
+            '@type': 'Answer',
+            text: item.answer,
+          },
+        })),
+      }),
+    })
+  }
+
+  useHead({ script: scripts })
+}

package/src/runtime/plugins/fathom.client.ts

@@ -0,0 +1,17 @@
+export default defineNuxtPlugin(() => {
+  const config = useRuntimeConfig()
+  const siteId = config.public.fathomSiteId as string
+
+  if (!siteId) return
+
+  useHead({
+    script: [
+      {
+        src: 'https://cdn.usefathom.com/script.js',
+        'data-site': siteId,
+        'data-spa': 'auto',
+        defer: true,
+      },
+    ],
+  })
+})

package/src/runtime/plugins/sentry.client.ts

@@ -0,0 +1,17 @@
+import * as Sentry from '@sentry/vue'
+
+export default defineNuxtPlugin((nuxtApp) => {
+  const config = useRuntimeConfig()
+  const dsn = config.public.sentryDsn as string
+
+  if (!dsn) return
+
+  Sentry.init({
+    app: nuxtApp.vueApp,
+    dsn,
+    environment: import.meta.dev ? 'development' : 'production',
+    tracesSampleRate: 0.1,
+    replaysSessionSampleRate: 0,
+    replaysOnErrorSampleRate: 1.0,
+  })
+})

package/src/runtime/server/api/newsletter/subscribe.post.ts

@@ -0,0 +1,35 @@
+import { defineEventHandler, readBody, createError } from 'h3'
+
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event)
+  const email = body?.email?.trim()
+
+  if (!email || !email.includes('@')) {
+    throw createError({ statusCode: 400, statusMessage: 'Valid email required' })
+  }
+
+  const config = useRuntimeConfig()
+  const apiKey = config.newsletterApiKey
+  const formId = config.convertkitFormId
+
+  if (!apiKey || !formId) {
+    console.warn(
+      '[newsletter] Missing NUXT_NEWSLETTER_API_KEY or NUXT_CONVERTKIT_FORM_ID -- subscription not sent',
+    )
+    return { success: true, message: 'Subscribed (dev mode)' }
+  }
+
+  try {
+    await $fetch(`https://api.convertkit.com/v3/forms/${formId}/subscribe`, {
+      method: 'POST',
+      body: {
+        api_key: apiKey,
+        email,
+      },
+    })
+    return { success: true }
+  } catch (err) {
+    console.error('[newsletter] Subscription failed:', err)
+    throw createError({ statusCode: 500, statusMessage: 'Subscription failed' })
+  }
+})

package/src/runtime/server/api/products/[slug].get.ts

@@ -0,0 +1,38 @@
+import { readFileSync, existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { parse } from 'yaml'
+import { defineEventHandler, getRouterParam, createError } from 'h3'
+import { injectAffiliateTag } from '../../utils/injectAffiliateTag'
+
+export default defineEventHandler((event) => {
+  const slug = getRouterParam(event, 'slug')
+  if (!slug) {
+    throw createError({ statusCode: 400, statusMessage: 'Product slug required' })
+  }
+
+  const dataDir = resolve(process.cwd(), 'data/products')
+  const niches = [
+    'skincare',
+    'home',
+    'boardgames',
+    'pets',
+    'coffee',
+    'books',
+    'fashion',
+    'fitness',
+    'food',
+    'merch',
+    'wellness',
+  ]
+
+  for (const niche of niches) {
+    const filePath = join(dataDir, niche, `${slug}.yaml`)
+    if (existsSync(filePath)) {
+      const content = readFileSync(filePath, 'utf-8')
+      const product = parse(content)
+      return injectAffiliateTag(product)
+    }
+  }
+
+  throw createError({ statusCode: 404, statusMessage: `Product not found: ${slug}` })
+})

package/src/runtime/server/api/products/index.get.ts

@@ -0,0 +1,36 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { parse } from 'yaml'
+import { defineEventHandler } from 'h3'
+import { injectAffiliateTag } from '../../utils/injectAffiliateTag'
+
+export default defineEventHandler(() => {
+  const dataDir = resolve(process.cwd(), 'data/products')
+  const niches = [
+    'skincare',
+    'home',
+    'boardgames',
+    'pets',
+    'coffee',
+    'books',
+    'fashion',
+    'fitness',
+    'food',
+    'merch',
+    'wellness',
+  ]
+  const products = []
+
+  for (const niche of niches) {
+    const nicheDir = join(dataDir, niche)
+    if (!existsSync(nicheDir)) continue
+    const files = readdirSync(nicheDir).filter((f) => f.endsWith('.yaml'))
+    for (const file of files) {
+      const content = readFileSync(join(nicheDir, file), 'utf-8')
+      const product = parse(content)
+      products.push(injectAffiliateTag(product))
+    }
+  }
+
+  return products
+})

package/src/runtime/server/routes/feed.xml.ts

@@ -0,0 +1,45 @@
+import { defineEventHandler } from 'h3'
+
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig()
+  const siteUrl = config.public?.siteUrl || 'http://localhost:3000'
+
+  // @ts-expect-error -- Server queryCollection takes (event, collection); vue-tsc resolves client types
+  const articles = await queryCollection(event, 'articles')
+    // @ts-expect-error -- publishedAt exists on articles collection but not on union type
+    .order('publishedAt', 'DESC')
+    .limit(50)
+    .all()
+
+  const siteName = config.public?.siteName || 'Site'
+
+  const rssItems = articles
+    .map((article) => {
+      const link = `${siteUrl}${article.path}`
+      // @ts-expect-error -- publishedAt exists on articles collection items
+      const pubDate = article.publishedAt ? new Date(article.publishedAt).toUTCString() : ''
+      return `    <item>
+      <title><![CDATA[${article.title || ''}]]></title>
+      <link>${link}</link>
+      <description><![CDATA[${article.description || ''}]]></description>
+      <pubDate>${pubDate}</pubDate>
+      <guid isPermaLink="true">${link}</guid>
+    </item>`
+    })
+    .join('\n')
+
+  const rss = `<?xml version="1.0" encoding="UTF-8"?>
+<rss version="2.0" xmlns:atom="http://www.w3.org/2005/Atom">
+  <channel>
+    <title>${siteName}</title>
+    <link>${siteUrl}</link>
+    <description>${siteName} - Latest Articles</description>
+    <language>en-us</language>
+    <atom:link href="${siteUrl}/feed.xml" rel="self" type="application/rss+xml"/>
+${rssItems}
+  </channel>
+</rss>`
+
+  setResponseHeader(event, 'content-type', 'application/xml; charset=utf-8')
+  return rss
+})

package/src/runtime/server/routes/sitemap.xml.ts

@@ -0,0 +1,121 @@
+import { readFileSync, readdirSync, existsSync } from 'node:fs'
+import { join, resolve } from 'node:path'
+import { parse } from 'yaml'
+
+export default defineEventHandler(async (event) => {
+  const config = useRuntimeConfig()
+  const siteUrl = config.public.siteUrl || 'http://localhost:3000'
+
+  // @ts-expect-error -- Server queryCollection takes (event, collection); vue-tsc resolves client types
+  const articles = await queryCollection(event, 'articles').all()
+  // @ts-expect-error -- Server queryCollection takes (event, collection); vue-tsc resolves client types
+  const pages = await queryCollection(event, 'pages').all()
+
+  const comparisonUrls = getComparisonUrls()
+
+  const personaSlugs = (config.contentPersonaSlugs || '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+
+  const freePages = (config.contentFreePages || '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+
+  const categorySlugs = (config.contentCategorySlugs || '')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+
+  const urls = [
+    { loc: '/', priority: 1.0, changefreq: 'daily' },
+    ...pages.map((page) => ({
+      loc: page.path,
+      priority: 0.7,
+      changefreq: 'monthly',
+    })),
+    ...articles.map((article) => ({
+      loc: article.path,
+      priority: 0.8,
+      changefreq: 'weekly',
+      // @ts-expect-error -- updatedAt/publishedAt exist on articles collection items
+      lastmod: article.updatedAt || article.publishedAt,
+    })),
+    { loc: '/compare', priority: 0.7, changefreq: 'weekly' },
+    ...comparisonUrls.map((loc) => ({
+      loc,
+      priority: 0.6,
+      changefreq: 'monthly',
+    })),
+    ...personaSlugs.map((slug) => ({
+      loc: `/best-for/${slug}`,
+      priority: 0.6,
+      changefreq: 'monthly',
+    })),
+    ...freePages.map((slug) => ({
+      loc: `/free/${slug}`,
+      priority: 0.5,
+      changefreq: 'monthly',
+    })),
+    ...categorySlugs.map((slug) => ({
+      loc: `/category/${slug}`,
+      priority: 0.7,
+      changefreq: 'weekly',
+    })),
+  ]
+
+  const sitemap = `<?xml version="1.0" encoding="UTF-8"?>
+<urlset xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+${urls
+  .map(
+    (url) => `  <url>
+    <loc>${siteUrl}${url.loc}</loc>
+    <changefreq>${url.changefreq}</changefreq>
+    <priority>${url.priority}</priority>${url.lastmod ? `\n    <lastmod>${url.lastmod}</lastmod>` : ''}
+  </url>`,
+  )
+  .join('\n')}
+</urlset>`
+
+  setResponseHeader(event, 'content-type', 'application/xml')
+  return sitemap
+})
+
+function getComparisonUrls() {
+  const config = useRuntimeConfig()
+  const comparisonNiches = (config.contentComparisonNiches || 'coffee')
+    .split(',')
+    .map((s) => s.trim())
+    .filter(Boolean)
+
+  const dataDir = resolve(process.cwd(), 'data/products')
+  const products = []
+
+  for (const niche of comparisonNiches) {
+    const nicheDir = join(dataDir, niche)
+    if (!existsSync(nicheDir)) continue
+    const files = readdirSync(nicheDir).filter((f) => f.endsWith('.yaml'))
+    for (const file of files) {
+      try {
+        const content = readFileSync(join(nicheDir, file), 'utf-8')
+        const product = parse(content)
+        if (product.slug && product.category) {
+          products.push({ slug: product.slug, category: product.category })
+        }
+      } catch {
+        // Skip malformed files
+      }
+    }
+  }
+
+  const urls = []
+  for (let i = 0; i < products.length; i++) {
+    for (let j = i + 1; j < products.length; j++) {
+      if (products[i].category === products[j].category) {
+        urls.push(`/compare/${products[i].slug}-vs-${products[j].slug}`)
+      }
+    }
+  }
+  return urls.slice(0, 50)
+}

package/src/runtime/server/utils/injectAffiliateTag.ts

@@ -0,0 +1,17 @@
+/**
+ * Replaces placeholder affiliate tags in product Amazon URLs
+ * with the real tag from environment config.
+ */
+export function injectAffiliateTag(product) {
+  const config = useRuntimeConfig()
+  const amazonTag = config.amazonAffiliateTag || ''
+
+  if (!amazonTag || !product.amazon) return product
+
+  const amazon = product.amazon
+  if (amazon.url && amazon.url.includes('YOURTAG-20')) {
+    amazon.url = amazon.url.replace('YOURTAG-20', amazonTag)
+  }
+
+  return { ...product, amazon }
+}