feat(apps/web): sitemap

.gitignore

@@ -15,7 +15,6 @@ out/
 build
 dist
 robots.txt
-sitemap*.xml
 analyze/
 
 # misc

apps/web/src/app/(cms)/academy/components/difficulty-label.tsx

@@ -10,6 +10,8 @@ interface DifficultyLabel {
 export function DifficultyLabel({ article, isCard }: DifficultyLabel) {
   const difficulty = article.difficulty
 
+  if (!difficulty) return <></>
+
   const slug = difficulty.slug as keyof typeof DIFFICULTY_ELEMENTS
   if (!slug) return <></>
 

apps/web/src/app/(cms)/academy/sitemap.ts

@@ -0,0 +1,44 @@
+import { getAcademyArticles } from '@sushiswap/graph-client/strapi'
+import type { MetadataRoute } from 'next'
+
+const products = ['bentobox', 'furo', 'onsen', 'sushixswap']
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  try {
+    const { articles } = await getAcademyArticles({
+      pagination: { pageSize: 10000 },
+    })
+
+    return [
+      {
+        url: 'https://sushi.com/academy',
+        lastModified: new Date(),
+        changeFrequency: 'yearly',
+      },
+      {
+        url: 'https://sushi.com/academy/explore',
+        lastModified: new Date(),
+        changeFrequency: 'yearly',
+      },
+      ...products.map(
+        (product) =>
+          ({
+            url: `https://sushi.com/academy/products/${product}`,
+            lastModified: new Date(),
+            changeFrequency: 'yearly',
+          }) as const,
+      ),
+      ...articles.map(
+        (article) =>
+          ({
+            url: `https://sushi.com/academy/${article.slug}`,
+            lastModified: new Date(article.updatedAt),
+            changeFrequency: 'weekly',
+          }) as const,
+      ),
+    ]
+  } catch {
+    console.error('sitemap: Error fetching academy articles')
+    return []
+  }
+}

apps/web/src/app/(cms)/blog/sitemap.ts

@@ -0,0 +1,29 @@
+import { getBlogArticles } from '@sushiswap/graph-client/strapi'
+import type { MetadataRoute } from 'next'
+
+export default async function sitemap(): Promise<MetadataRoute.Sitemap> {
+  try {
+    const { articles } = await getBlogArticles({
+      pagination: { pageSize: 10000 },
+    })
+
+    return [
+      {
+        url: 'https://sushi.com/blog',
+        lastModified: new Date(),
+        changeFrequency: 'yearly',
+      },
+      ...articles.map(
+        (article) =>
+          ({
+            url: `https://sushi.com/blog/${article.slug}`,
+            lastModified: new Date(article.updatedAt),
+            changeFrequency: 'weekly',
+          }) as const,
+      ),
+    ]
+  } catch {
+    console.error('sitemap: Error fetching blog articles')
+    return []
+  }
+}

apps/web/src/app/(networks)/(non-evm)/aptos/sitemap.ts

@@ -0,0 +1,14 @@
+import type { MetadataRoute } from 'next'
+
+const aptosChainPaths = ['/pool', '/explore/pools', '/pool/add', '/swap']
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return aptosChainPaths.map(
+    (path) =>
+      ({
+        url: `https://sushi.com/aptos/${path}`,
+        lastModified: new Date(),
+        changeFrequency: 'weekly',
+      }) as const,
+  )
+}

apps/web/src/app/(networks)/(non-evm)/tron/sitemap.ts

@@ -0,0 +1,14 @@
+import type { MetadataRoute } from 'next'
+
+const tronChainPaths = ['/pool', '/explore/pools', '/pool/add', '/swap']
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return tronChainPaths.map(
+    (path) =>
+      ({
+        url: `https://sushi.com/tron/${path}`,
+        lastModified: new Date(),
+        changeFrequency: 'weekly',
+      }) as const,
+  )
+}

apps/web/src/app/legal/[slug]/page.tsx

@@ -2,35 +2,30 @@ import { Container, Separator } from '@sushiswap/ui'
 import { unstable_cache } from 'next/cache'
 import React from 'react'
 import { getGhostBody } from 'src/app/(cms)/lib/ghost/ghost'
+import { legalPages } from '../_config'
 
 export const revalidate = 86400
 
 export const dynamicParams = false
 
-const pages = {
-  ['privacy-policy']: { title: 'Privacy Policy' },
-  ['terms-of-service']: { title: 'Terms of Service' },
-  ['cookie-policy']: { title: 'Cookie Policy' },
-}
-
 export async function generateStaticParams() {
-  return Object.keys(pages).map((slug) => ({ slug: slug }))
+  return Object.keys(legalPages).map((slug) => ({ slug: slug }))
 }
 
 type Props = {
-  params: { slug: keyof typeof pages }
+  params: { slug: keyof typeof legalPages }
 }
 
 export async function generateMetadata({ params }: Props) {
-  const page = pages[params.slug]
+  const page = legalPages[params.slug]
 
   return {
     title: page.title,
   }
 }
 
 export default async function Page({ params }: Props) {
-  const page = pages[params.slug]
+  const page = legalPages[params.slug]
 
   const {
     title,

apps/web/src/app/legal/_config.ts

@@ -0,0 +1,5 @@
+export const legalPages = {
+  ['privacy-policy']: { title: 'Privacy Policy' },
+  ['terms-of-service']: { title: 'Terms of Service' },
+  ['cookie-policy']: { title: 'Cookie Policy' },
+}

apps/web/src/app/legal/sitemap.ts

@@ -0,0 +1,13 @@
+import type { MetadataRoute } from 'next'
+import { legalPages } from './_config'
+
+export default function sitemap(): MetadataRoute.Sitemap {
+  return Object.keys(legalPages).map(
+    (page) =>
+      ({
+        url: `https://sushi.com/legal/${page}`,
+        lastModified: new Date(),
+        changeFrequency: 'weekly',
+      }) as const,
+  )
+}

apps/web/src/app/robots.ts

@@ -0,0 +1,11 @@
+import { MetadataRoute } from 'next'
+
+export default function robots(): MetadataRoute.Robots {
+  return {
+    rules: {
+      userAgent: '*',
+      allow: ['/'],
+    },
+    sitemap: 'https://sushi.com/sitemap-index.xml',
+  }
+}

apps/web/src/app/sitemap-index.xml/route.ts

@@ -0,0 +1,25 @@
+import { CHAIN_IDS } from 'src/config'
+import { getNetworkKey } from 'src/lib/network'
+
+const networkKeys = [...CHAIN_IDS.map(getNetworkKey), 'aptos', 'tron']
+
+const sitemapFiles = [
+  '/academy/sitemap.xml',
+  '/blog/sitemap.xml',
+  ...networkKeys.map((key) => `/sitemap.xml/${key}`),
+  '/legal/sitemap.xml',
+]
+
+const generateSitemapLink = (url: string) =>
+  `<sitemap><loc>https://sushi.com${url}</loc></sitemap>`
+
+export async function GET() {
+  const sitemapIndexXML = `<?xml version="1.0" encoding="UTF-8"?>
+    <sitemapindex xmlns="http://www.sitemaps.org/schemas/sitemap/0.9">
+        ${sitemapFiles.map((file) => generateSitemapLink(file)).join('')}
+    </sitemapindex>`
+
+  return new Response(sitemapIndexXML, {
+    headers: { 'Content-Type': 'text/xml' },
+  })
+}

apps/web/src/app/sitemap.ts

@@ -0,0 +1,36 @@
+import { MetadataRoute } from 'next'
+import { CHAIN_IDS } from 'src/config'
+import { getNetworkKey } from 'src/lib/network'
+
+const evmChainPaths = [
+  '/migrate',
+  '/pool',
+  '/rewards',
+  '/cross-chain-swap',
+  '/dca',
+  '/limit',
+  '/swap',
+  '/explore/pools',
+  '/explore/smart-pools',
+  '/pool/incentivize',
+  '/pool/v2/add',
+  '/pool/v3/add',
+  '/pool/v3/fees',
+]
+
+export async function generateSitemaps() {
+  return CHAIN_IDS.map((chainId) => ({
+    id: getNetworkKey(chainId),
+  }))
+}
+
+export default function sitemap({ id }: { id: string }): MetadataRoute.Sitemap {
+  return evmChainPaths.map(
+    (path) =>
+      ({
+        url: `https://sushi.com/${id}${path}`,
+        lastModified: new Date(),
+        changeFrequency: 'weekly',
+      }) as const,
+  )
+}

packages/graph-client/src/subgraphs/strapi/queries/academy-articles.ts

@@ -133,12 +133,14 @@ export async function getAcademyArticles(
       id: topic.id,
       name: topic.attributes.name,
     })),
-    difficulty: {
-      id: article.attributes.difficulty!.data!.id,
-      name: article.attributes.difficulty!.data!.attributes.name,
-      label: article.attributes.difficulty!.data!.attributes.label,
-      slug: article.attributes.difficulty!.data!.attributes.slug,
-    },
+    difficulty: article.attributes.difficulty.data
+      ? {
+          id: article.attributes.difficulty.data.id,
+          name: article.attributes.difficulty.data.attributes.name,
+          label: article.attributes.difficulty.data.attributes.label,
+          slug: article.attributes.difficulty.data.attributes.slug,
+        }
+      : null,
     cover: transformImage(article.attributes.cover.data!),
     authors: article.attributes.authors!.data.map((author) => ({
       name: author.attributes.name,