@vigilkids/cms-nuxt 0.3.0 → 0.5.0

package/CHANGELOG.md

@@ -0,0 +1,111 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [0.5.0] - 2026-06-03
+
+### Added
+
+- Added `useLocalizedResourceSeo()` for locale-aware CMS resource metadata, canonical links, Open Graph tags, and Twitter Card tags.
+- Added category metadata exposure in `useCmsCategories()` for taxonomy landing pages.
+
+### Changed
+
+- `useBlogSeo()` now delegates to the shared localized resource SEO pipeline.
+- Updated peer dependency to `@vigilkids/cms-client ^0.3.0`.
+
+## [0.4.0] - 2026-06-03
+
+### Added
+
+- Product-agnostic Resource Route Policy through `routes.resources`, `routes.sourceResources`, and `routes.locale`, allowing each consuming product to define public CMS resource paths without changing package runtime code.
+- Configurable CMS content integration endpoints: article collection path, CMS fetch proxy path, preview path, revalidate path, and sitemap source path.
+- `useCmsRoutes()` composable for route-policy access and resource path generation.
+- `useCmsArticleCollection()` composable backed by the module-owned normalized article collection endpoint.
+- `useCmsCategories()` composable for preloaded category data, category lookup, and route-policy category path generation.
+- Generic preview route resolution for resource types and route params, including source route parsing and route-policy public redirects.
+- Route-policy-aware sitemap source endpoint and optional `@nuxtjs/sitemap` provider integration.
+
+### Changed
+
+- Module setup now uses the `cms` module options as the source of truth and derives server/private and public runtime config from those options.
+- Preview, revalidate, and sitemap URL generation now build paths from Resource Route Policy instead of a fixed article URL shape.
+- Client-side CMS fetches now use the module CMS proxy while SSR fetches continue to call the CMS API directly.
+- Dynamic CMS endpoints are registered with no-cache Nitro route rules.
+
+### Removed
+
+- Package-owned hardcoded public article route assumptions from preview, revalidate, and sitemap path generation.
+- Direct consumer setup guidance that required writing CMS runtime config keys manually.
+
+## [0.3.0] - 2026-05-08
+
+### Breaking Changes
+
+- `useArticle` no longer auto-injects hreflang `<link>` tags. The previous implementation hardcoded a `/blog/{slug}` URL pattern, which silently produced incorrect `href` values for any consumer whose article routes are not exactly `/{locale}/blog/{slug}` (e.g. category-based routes like `/{locale}/{category}/{slug}/`). Hreflang URL pattern is consumer-domain knowledge and must be supplied explicitly.
+
+### Added
+
+- `useHreflangLinks(resource, builder)` composable — generic hreflang `<link>` injector that filters by the resource's `available_locales` and adds an `x-default` entry. Works for any CMS resource with `slug`, `available_locales`, and `localized_slugs` fields (articles, authors, future series, etc.). The `builder` callback decides URL paths, locale prefix strategy, trailing slash, and origin, so it adapts to any route structure without forking the package.
+
+### Migration
+
+If you previously relied on `useArticle`'s auto hreflang:
+
+```ts
+// 0.2.x — implicit, hardcoded /blog/{slug}
+const { article } = useArticle(slug)
+
+// 0.3.0 — explicit, consumer-defined URL pattern
+const { article } = useArticle(slug)
+useHreflangLinks(article, ({ locale, slug, resource }) => {
+  const origin = `https://${siteUrl}`
+  if (locale === 'x-default') return `${origin}/blog/${slug}`
+  return `${origin}/${locale}/blog/${slug}`
+})
+```
+
+Consumers using non-`/blog/` routes (e.g. marketing site `/{category}/{slug}/`) were silently outputting broken hreflang under 0.2.x and should migrate immediately.
+
+## [0.2.1] - 2026-03-24
+
+### Fixed
+
+- Preview pages showing stale content after edits — Nitro SWR cache key now includes a unique timestamp for preview requests, ensuring each refresh bypasses the route-level SWR cache and renders fresh draft content
+
+## [0.2.0] - 2026-03-24
+
+### Added
+
+- `useCmsPreviewToken()` composable — SWR-safe preview token reading (SSR reads from `event.context`, CSR reads from cookie)
+- `preview-context` server middleware — copies preview cookie to `event.context` so it survives Nitro SWR synthetic events
+- Preview redirect now appends `?_preview=1` for separate SWR cache key isolation (prevents draft content leaking to public cache)
+
+### Fixed
+
+- Preview 404 when Nitro SWR caching is enabled — SWR synthetic events strip all request headers including cookies, causing preview token loss during SSR rendering
+- ISR revalidation cache key mismatch — `_revalidate.post.ts` now uses Nitro's internal key format (`escapeKey + hash`) with prefix matching instead of naive path-to-key conversion
+
+## [0.1.0] - 2026-03-23
+
+### Added
+
+- ESLint flat config (`@antfu/eslint-config` + Vue) + Prettier
+
+### Changed
+
+- Codebase formatted with Prettier (singleQuote, no semi, printWidth 100)
+
+## [0.0.1] - 2025-03-23
+
+### Added
+
+- Nuxt 3 module for CMS integration (`@vigilkids/cms-nuxt`)
+- Auto-registered composables: `useCmsArticle`, `useCmsPreview`, `useCmsSitemap`
+- Server API route for preview token validation with secure cookie
+- Preview mode middleware with cookie-based authentication
+- Sitemap provider integration with `@nuxtjs/sitemap`
+- Runtime config integration for CMS API base URL

package/README.md

@@ -1,56 +1,273 @@
 # @vigilkids/cms-nuxt
 
-Nuxt 3 module for OneX CMS integration. Provides auto-imported composables, preview mode, and sitemap integration.
+Nuxt module for product-agnostic OneX CMS integration. It registers the CMS runtime configuration, auto-imported composables, Nuxt server endpoints, preview support, cache revalidation, route-policy URL generation, and optional `@nuxtjs/sitemap` integration.
+
+The package owns the CMS client boundary and resource route policy. Consuming products own Nuxt page shells and choose the public URL shape through module options.
 
 ## Install
 
 ```bash
-pnpm add @vigilkids/cms-nuxt
+pnpm add @vigilkids/cms-nuxt @vigilkids/cms-client
 ```
 
-**Peer Dependencies:**
-- `nuxt` ≥ 3.15
-- `@vigilkids/cms-client` (workspace)
-- `@nuxtjs/sitemap` (optional)
+## Peer Dependencies
+
+- `nuxt >=3.15.0`
+- `@vigilkids/cms-client ^0.3.0`
+- `@nuxtjs/sitemap` is optional and only required when `cms.sitemap.enabled` is `true`
 
-## Setup
+## Module Setup
+
+Configure the module with the `cms` key in `nuxt.config.ts`. Do not create CMS `runtimeConfig` values by hand; the module derives the server and public runtime config from these options.
 
 ```typescript
-// nuxt.config.ts
 export default defineNuxtConfig({
   modules: ['@vigilkids/cms-nuxt'],
-  runtimeConfig: {
-    cmsApiBaseUrl: 'https://api.example.com',
-    cmsApiKey: '',
+
+  cms: {
+    apiUrl: process.env.NUXT_CMS_API_URL ?? '',
+    productCode: process.env.NUXT_CMS_PRODUCT_CODE ?? '',
+    defaultLocale: 'en',
+    webhookSecret: process.env.NUXT_CMS_WEBHOOK_SECRET ?? '',
+
+    routes: {
+      resources: {
+        index: '/resources',
+        category: '/resources/{category_slug}',
+        article: '/resources/{category_slug}/{slug}',
+        author: '/resources/authors/{slug}',
+      },
+      sourceResources: {
+        index: '/',
+        category: '/{category_slug}',
+        article: '/{category_slug}/{slug}',
+        author: '/authors/{slug}',
+      },
+      locale: {
+        defaultLocale: 'en',
+        prefixes: {
+          'zh-CN': 'zh',
+        },
+        includeDefaultLocale: false,
+      },
+    },
+
+    localeMap: {
+      'zh-CN': 'zh',
+    },
+
+    content: {
+      articleCollectionPath: '/api/cms/articles',
+      cmsProxyPath: '/cms-proxy',
+    },
+
+    categories: {
+      preload: true,
+    },
+
+    preview: {
+      enabled: true,
+      path: '/api/preview',
+      cookieName: '__preview_token',
+      cookieMaxAge: 1800,
+    },
+
+    revalidate: {
+      enabled: true,
+      path: '/api/_revalidate',
+    },
+
+    sitemap: {
+      enabled: true,
+      locales: ['en', 'zh-CN'],
+      sourcePath: '/api/cms/sitemap-urls',
+    },
   },
 })
 ```
 
-## Auto-Imported Composables
+## Module Options
+
+| Option | Default | Purpose |
+| --- | --- | --- |
+| `apiUrl` | `''` | CMS API base URL used by `CmsClient`, server routes, and SSR fetches. |
+| `productCode` | `''` | Sent as `X-Product-Code` when present. |
+| `defaultLocale` | `'en'` | Public default locale used by composables and route policy. |
+| `webhookSecret` | `''` | Server-only HMAC secret for the revalidate endpoint. |
+| `routes.resources` | built-in defaults | Public resource URL patterns generated by `useCmsRoutes`, preview, revalidate, and sitemap. |
+| `routes.sourceResources` | built-in defaults | CMS API resource URL patterns used to parse preview and sitemap input before rebuilding public URLs. |
+| `routes.locale` | default locale policy | Locale prefix policy for generated public URLs. |
+| `content.articleCollectionPath` | `'/api/cms/articles'` | Nuxt server endpoint for normalized article collection queries. |
+| `content.cmsProxyPath` | `'/cms-proxy'` | Nuxt server proxy prefix used by client-side CMS fetches. |
+| `categories.preload` | `false` | Fetches `/categories` during module setup and exposes the result in public runtime config. |
+| `preview` | enabled by default | Preview route and preview cookie behavior. |
+| `revalidate` | enabled by default | Signed ISR cache invalidation endpoint. |
+| `redirects` | enabled by default | CMS redirect middleware with configurable in-memory cache TTL. |
+| `sitemap` | disabled by default | `@nuxtjs/sitemap` provider integration and sitemap source endpoint path. |
+| `localeMap` | `{}` | Maps public locale codes to CMS API locale codes. |
+| `localePrefixes` | `{}` | Additional prefix input merged into `routes.locale.prefixes`. |
+
+## Resource Route Policy
+
+Resource Route Policy is the package's public URL extension point. It keeps the CMS integration product-neutral: the package knows how to build and parse resource routes, while each product chooses its page structure.
+
+Default resource patterns are:
+
+```typescript
+const defaultResourcePatterns = {
+  index: '/',
+  category: '/{category_slug}',
+  article: '/{category_slug}/{slug}',
+  author: '/authors/{slug}',
+} as const
+```
+
+`routes.resources` defines public site paths. `routes.sourceResources` defines the path shape returned by CMS preview and sitemap payloads when that source path differs from the public site path. `routes.locale` controls locale prefixes:
 
 ```typescript
-// Available in any Vue component without import
-const { article, pending } = useCmsArticle('my-slug', { locale: 'en' })
-const { isPreview, previewToken } = useCmsPreview()
+export default defineNuxtConfig({
+  cms: {
+    routes: {
+      resources: {
+        article: '/learn/{category_slug}/{slug}',
+      },
+      sourceResources: {
+        article: '/{category_slug}/{slug}',
+      },
+      locale: {
+        defaultLocale: 'en',
+        prefixes: { fr: 'fr' },
+        includeDefaultLocale: false,
+      },
+    },
+  },
+})
 ```
 
-## Preview Mode
+`useCmsRoutes()` exposes the resolved policy and route builder:
 
-The module registers a server route at `/api/preview` that validates preview tokens and sets a secure httpOnly cookie. Frontend middleware automatically detects preview mode.
+```vue
+<script setup lang="ts">
+const cmsRoutes = useCmsRoutes()
 
+const articlePath = cmsRoutes.build('article', {
+  category_slug: 'guides',
+  slug: 'getting-started',
+  locale: 'fr',
+}, true)
+</script>
 ```
-GET /api/preview?token=xxx&slug=my-article&locale=en
-→ Sets preview cookie → Redirects to article page
+
+A new product should change only:
+
+- `cms.routes.resources`, `cms.routes.sourceResources`, and `cms.routes.locale`
+- Nuxt page shells that map those URL patterns to UI components
+
+The CMS client, preview endpoint, revalidation endpoint, category preload, fetch proxy, and sitemap source stay inside the package.
+
+## Content Endpoints
+
+The module registers no-cache Nuxt server endpoints from the configured paths.
+
+| Endpoint | Method | Behavior |
+| --- | --- | --- |
+| `content.articleCollectionPath` | `GET` | Returns `Paginated<ArticleListItem>` with `locale`, `category_slug`, `q`, `page`, and `page_size` query support. Search results are normalized into article cards. |
+| `${content.cmsProxyPath}/**` | any | Proxies client-side CMS requests to `apiUrl`, forwarding `X-Product-Code` and preview token headers when present. |
+| `sitemap.sourcePath` | `GET` | Returns Nuxt sitemap entries for `?locale=...` using route policy and CMS sitemap data. |
+| `preview.path` | `GET` | Reads preview input, sets the preview cookie, and redirects to the route-policy-generated resource path. |
+| `revalidate.path` | `POST` | Verifies `x-webhook-signature` and clears matching Nitro route cache entries. |
+
+## Categories
+
+Set `categories.preload` to `true` when category navigation or route guards need category data at render time. The module fetches `${apiUrl}/categories` during setup and exposes the data to `useCmsCategories()`.
+
+```vue
+<script setup lang="ts">
+const { currentCategories, getCategoryPath, categoryExists } = useCmsCategories()
+</script>
 ```
 
+Use `useCategories()` when the page should fetch categories through `@vigilkids/cms-client` with `useAsyncData`.
+
+## Preview
+
+Preview mode is enabled unless `preview.enabled` is `false`.
+
+```http
+GET /api/preview?token=preview-token&resource=article&slug=guides/getting-started&locale=en
+```
+
+The preview endpoint:
+
+- reads `token`, `resource` or `resource_type`, `slug`, `locale`, and additional route params from the query string
+- parses `slug` with `routes.sourceResources` when possible
+- fetches article detail when the public article pattern requires `category_slug`
+- sets the configured preview cookie
+- redirects to the generated public route with `_preview=1`
+
+`useCmsPreview()` returns `{ isPreview, previewToken, exitPreview }`. `useCmsPreviewToken()` is available for lower-level integrations.
+
+## Revalidate
+
+The revalidate endpoint is enabled unless `revalidate.enabled` is `false`. It expects a raw JSON CMS webhook payload signed with `@vigilkids/cms-client/webhook` HMAC verification.
+
+```http
+POST /api/_revalidate
+X-Webhook-Signature: sha256=...
+Content-Type: application/json
+```
+
+```json
+{
+  "event": "article.published",
+  "resource_type": "article",
+  "locale": "en",
+  "slug": "getting-started",
+  "category_slug": "guides",
+  "route_params": {
+    "category_slug": "guides",
+    "slug": "getting-started"
+  }
+}
+```
+
+The endpoint builds index, category, and resource paths with the configured route policy, then removes matching Nitro route cache entries.
+
 ## Sitemap
 
-When `@nuxtjs/sitemap` is installed, the module automatically provides CMS article URLs to the sitemap.
+There are two sitemap integration surfaces:
+
+- `GET sitemap.sourcePath?locale=en` returns route-policy-generated sitemap entries for a single locale.
+- `sitemap.enabled: true` hooks into `@nuxtjs/sitemap` and pushes CMS entries for `sitemap.locales`.
+
+CMS sitemap entries can include resource types, route params, hreflang alternatives, images, `last_mod`, `change_freq`, and `priority`. The package converts them into Nuxt sitemap entries with public paths generated from the route policy.
+
+## Composables
+
+All runtime composables are auto-imported.
+
+| Composable | Purpose |
+| --- | --- |
+| `useCmsClient()` | Returns a `CmsClient` configured from public CMS runtime config and preview token state. |
+| `useCmsFetch<T>(path, options)` | SSR fetches CMS directly and CSR fetches through `content.cmsProxyPath`. |
+| `useArticle(slug)` | Fetches article detail, related articles, SEO meta, Open Graph meta, Twitter meta, and JSON-LD. |
+| `useArticleList(params)` | Fetches article lists through `CmsClient.getArticles`. |
+| `useCmsArticleCollection(params)` | Fetches the normalized article collection endpoint with category, search, and pagination support. |
+| `useCategories()` | Fetches categories through `CmsClient.getCategories`. |
+| `useCmsCategories()` | Reads preloaded category data and exposes category lookup/path helpers. |
+| `useAuthor(slug)` | Fetches author detail and author articles. |
+| `useCmsPreviewToken()` | Reads the preview token in SSR and CSR contexts. |
+| `useCmsPreview()` | Exposes preview state and exit behavior. |
+| `useCmsRoutes()` | Exposes the resolved route policy and route builder. |
+| `useBlogSeo(options)` | Applies list-page SEO meta. |
+| `useHreflangLinks(resource, builder)` | Injects alternate links from resource locales with caller-defined URL building. |
 
 ## Compatibility
 
-- Nuxt ≥ 3.15
-- Node.js ≥ 18
+- Nuxt `>=3.15.0`
+- `@vigilkids/cms-client ^0.3.0`
+- Vue runtime supplied by Nuxt
+- Node.js version should satisfy the consuming Nuxt application's runtime requirements
 
 ## License
 

package/dist/module.d.mts

@@ -1,5 +1,28 @@
 import { NuxtModule } from '@nuxt/schema';
 
+/** CMS 资源路由模式 */
+interface CmsRouteResources {
+    index?: string;
+    category?: string;
+    article?: string;
+    author?: string;
+    [resource: string]: string | undefined;
+}
+/** CMS 语言路径策略 */
+interface CmsRouteLocalePolicy {
+    defaultLocale?: string;
+    prefixes?: Record<string, string>;
+    includeDefaultLocale?: boolean;
+}
+/** CMS 资源路由策略 */
+interface CmsRoutePolicy {
+    /** 站点公开 URL 模式 */
+    resources?: CmsRouteResources;
+    /** CMS API 返回的资源 URL 模式，用于 preview/sitemap 输入解析 */
+    sourceResources?: CmsRouteResources;
+    /** 语言路径策略 */
+    locale?: CmsRouteLocalePolicy;
+}
 /** CMS Nuxt Module 配置 */
 interface CmsNuxtModuleOptions {
     /** CMS API 基础 URL */
@@ -13,10 +36,21 @@ interface CmsNuxtModuleOptions {
     /** 预览模式配置 */
     preview?: {
         enabled?: boolean;
+        path?: string;
         cookieName?: string;
         cookieMaxAge?: number;
-        /** 文章路径模式，slug 会替换 {slug} 占位符。默认 '/blog/{slug}' */
-        articlePath?: string;
+    };
+    /** CMS 资源路由策略 */
+    routes?: CmsRoutePolicy;
+    /** 内容 API 集成 */
+    content?: {
+        articleCollectionPath?: string;
+        cmsProxyPath?: string;
+    };
+    /** 分类预加载配置 */
+    categories?: {
+        preload?: boolean;
+        locales?: string[];
     };
     /** ISR 重验证配置 */
     revalidate?: {
@@ -32,6 +66,7 @@ interface CmsNuxtModuleOptions {
     sitemap?: {
         enabled?: boolean;
         locales?: string[];
+        sourcePath?: string;
     };
     /** 语言代码映射 (前端 locale → CMS API locale) */
     localeMap?: Record<string, string>;

package/dist/module.d.ts

@@ -1,45 +1,6 @@
-import { NuxtModule } from '@nuxt/schema';
-
-/** CMS Nuxt Module 配置 */
-interface CmsNuxtModuleOptions {
-    /** CMS API 基础 URL */
-    apiUrl: string;
-    /** 产品编码 */
-    productCode: string;
-    /** 默认语言 */
-    defaultLocale?: string;
-    /** Webhook HMAC-SHA256 密钥（服务端专用） */
-    webhookSecret: string;
-    /** 预览模式配置 */
-    preview?: {
-        enabled?: boolean;
-        cookieName?: string;
-        cookieMaxAge?: number;
-        /** 文章路径模式，slug 会替换 {slug} 占位符。默认 '/blog/{slug}' */
-        articlePath?: string;
-    };
-    /** ISR 重验证配置 */
-    revalidate?: {
-        enabled?: boolean;
-        path?: string;
-    };
-    /** 重定向中间件配置 */
-    redirects?: {
-        enabled?: boolean;
-        cacheTtl?: number;
-    };
-    /** Sitemap 集成 */
-    sitemap?: {
-        enabled?: boolean;
-        locales?: string[];
-    };
-    /** 语言代码映射 (前端 locale → CMS API locale) */
-    localeMap?: Record<string, string>;
-    /** URL 路径前缀映射 (CMS locale → URL prefix)，默认语言无需配置 */
-    localePrefixes?: Record<string, string>;
-}
-
+import type { NuxtModule } from '@nuxt/schema';
+import type { CmsNuxtModuleOptions } from './types';
 declare const module: NuxtModule<CmsNuxtModuleOptions>;
-
-export { module as default };
-export type { CmsNuxtModuleOptions };
+export default module;
+export type { CmsNuxtModuleOptions } from './types';
+//# sourceMappingURL=module.d.ts.map

package/dist/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../src/module.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAQ,UAAU,EAAE,MAAM,cAAc,CAAA;AAEpD,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA;AAiEnD,QAAA,MAAM,MAAM,EAAE,UAAU,CAAC,oBAAoB,CAoJ3C,CAAA;AAEF,eAAe,MAAM,CAAA;AAGrB,YAAY,EAAE,oBAAoB,EAAE,MAAM,SAAS,CAAA"}

package/dist/module.json

@@ -4,7 +4,7 @@
   "compatibility": {
     "nuxt": ">=3.15.0"
   },
-  "version": "0.3.0",
+  "version": "0.5.0",
   "builder": {
     "@nuxt/module-builder": "0.8.4",
     "unbuild": "unknown"

package/dist/module.mjs

@@ -1,5 +1,43 @@
 import { defineNuxtModule, createResolver, addImportsDir, addServerImportsDir, addServerHandler, addPlugin } from '@nuxt/kit';
 
+function emptyCategoriesData() {
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  return { lastUpdated: now, buildTime: now, items: [] };
+}
+async function preloadCategoriesData(options) {
+  if (!options.apiUrl)
+    return emptyCategoriesData();
+  try {
+    const url = `${options.apiUrl.replace(/\/+$/g, "")}/categories`;
+    const headers = { Accept: "application/json" };
+    if (options.productCode)
+      headers["X-Product-Code"] = options.productCode;
+    const response = await fetch(url, { headers });
+    if (!response.ok)
+      return emptyCategoriesData();
+    const payload = await response.json();
+    const categories = Array.isArray(payload) ? payload : payload.data;
+    return {
+      lastUpdated: (/* @__PURE__ */ new Date()).toISOString(),
+      buildTime: (/* @__PURE__ */ new Date()).toISOString(),
+      items: categories.filter((category) => category.slug && category.name)
+    };
+  } catch {
+    return emptyCategoriesData();
+  }
+}
+function applyNoCacheRouteRules(nuxt, paths) {
+  const options = nuxt.options;
+  options.nitro = options.nitro ?? {};
+  options.nitro.routeRules = options.nitro.routeRules ?? {};
+  for (const path of paths) {
+    options.nitro.routeRules[path] = {
+      swr: false,
+      cache: false,
+      headers: { "cache-control": "private, no-cache, no-store" }
+    };
+  }
+}
 const module = defineNuxtModule({
   meta: {
     name: "@vigilkids/cms-nuxt",
@@ -12,14 +50,30 @@ const module = defineNuxtModule({
     defaultLocale: "en",
     webhookSecret: "",
     preview: { cookieName: "__preview_token", cookieMaxAge: 1800 },
+    content: { articleCollectionPath: "/api/cms/articles", cmsProxyPath: "/cms-proxy" },
+    categories: { preload: false },
     revalidate: { enabled: true, path: "/api/_revalidate" },
     redirects: { enabled: true, cacheTtl: 3e5 },
     sitemap: { enabled: false },
     localeMap: {},
     localePrefixes: {}
   },
-  setup(options, nuxt) {
+  async setup(options, nuxt) {
     const { resolve } = createResolver(import.meta.url);
+    const categoriesData = options.categories?.preload ? await preloadCategoriesData(options) : emptyCategoriesData();
+    const articleCollectionPath = options.content?.articleCollectionPath ?? "/api/cms/articles";
+    const cmsProxyPath = options.content?.cmsProxyPath ?? "/cms-proxy";
+    const cmsProxyRoute = cmsProxyPath.endsWith("/**") ? cmsProxyPath : `${cmsProxyPath}/**`;
+    const previewPath = options.preview?.path ?? "/api/preview";
+    const revalidatePath = options.revalidate?.path ?? "/api/_revalidate";
+    const sitemapSourcePath = options.sitemap?.sourcePath ?? "/api/cms/sitemap-urls";
+    applyNoCacheRouteRules(nuxt, [
+      articleCollectionPath,
+      cmsProxyRoute,
+      sitemapSourcePath,
+      previewPath,
+      revalidatePath
+    ]);
     nuxt.options.runtimeConfig.cms = {
       webhookSecret: options.webhookSecret,
       redirects: {
@@ -33,8 +87,26 @@ const module = defineNuxtModule({
       defaultLocale: options.defaultLocale ?? "en",
       preview: {
         cookieName: options.preview?.cookieName ?? "__preview_token",
-        cookieMaxAge: options.preview?.cookieMaxAge ?? 1800,
-        articlePath: options.preview?.articlePath ?? "/blog/{slug}"
+        cookieMaxAge: options.preview?.cookieMaxAge ?? 1800
+      },
+      routes: {
+        ...options.routes ?? {},
+        locale: {
+          defaultLocale: options.routes?.locale?.defaultLocale ?? options.defaultLocale ?? "en",
+          prefixes: {
+            ...options.localePrefixes ?? {},
+            ...options.routes?.locale?.prefixes ?? {}
+          },
+          includeDefaultLocale: options.routes?.locale?.includeDefaultLocale ?? false
+        }
+      },
+      content: {
+        articleCollectionPath,
+        cmsProxyPath
+      },
+      categories: categoriesData,
+      sitemap: {
+        sourcePath: sitemapSourcePath
       },
       localeMap: options.localeMap ?? {},
       localePrefixes: options.localePrefixes ?? {}
@@ -43,18 +115,32 @@ const module = defineNuxtModule({
     addServerImportsDir(resolve("./runtime/server/utils"));
     if (options.revalidate?.enabled !== false) {
       addServerHandler({
-        route: options.revalidate?.path ?? "/api/_revalidate",
+        route: revalidatePath,
         method: "post",
         handler: resolve("./runtime/server/api/_revalidate.post")
       });
     }
+    addServerHandler({
+      route: articleCollectionPath,
+      method: "get",
+      handler: resolve("./runtime/server/api/articles.get")
+    });
+    addServerHandler({
+      route: sitemapSourcePath,
+      method: "get",
+      handler: resolve("./runtime/server/api/sitemap-urls.get")
+    });
+    addServerHandler({
+      route: cmsProxyRoute,
+      handler: resolve("./runtime/server/routes/cms-proxy")
+    });
     if (options.preview?.enabled !== false) {
       addServerHandler({
         middleware: true,
         handler: resolve("./runtime/server/middleware/preview-context")
       });
       addServerHandler({
-        route: "/api/preview",
+        route: previewPath,
         method: "get",
         handler: resolve("./runtime/server/api/preview.get")
       });