@wpnuxt/core 2.0.0-beta.2 → 2.0.0-beta.4

package/dist/module.json

@@ -1,9 +1,9 @@
 {
   "name": "@wpnuxt/core",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "configKey": "wpNuxt",
   "compatibility": {
-    "nuxt": ">=3.0.0"
+    "nuxt": ">=3.17.0"
   },
   "builder": {
     "@nuxt/module-builder": "1.0.2",

package/dist/module.mjs

@@ -1,15 +1,14 @@
-import { consola } from 'consola';
 import { defu } from 'defu';
-import { promises, cpSync, existsSync, readdirSync, statSync, readFileSync, writeFileSync } from 'node:fs';
+import { promises, cpSync, existsSync, readdirSync, statSync, mkdirSync, readFileSync, writeFileSync } from 'node:fs';
 import { writeFile, rename, readFile, mkdir } from 'node:fs/promises';
 import { join, relative, dirname } from 'node:path';
-import { useLogger, createResolver, resolveFiles, defineNuxtModule, addPlugin, hasNuxtModule, addImports, addComponentsDir, addTemplate, addTypeTemplate, installModule } from '@nuxt/kit';
+import { useLogger, createResolver, resolveFiles, defineNuxtModule, addPlugin, addImports, addComponentsDir, addTemplate, addTypeTemplate, hasNuxtModule, installModule } from '@nuxt/kit';
 import { upperFirst } from 'scule';
-import { ref } from 'vue';
-import { parse, GraphQLError } from 'graphql';
+import { parse, GraphQLError, visit, print } from 'graphql';
 import { execSync } from 'node:child_process';
+import { consola } from 'consola';
 
-const version = "2.0.0-beta.2";
+const version = "2.0.0-beta.4";
 
 function createModuleError(module, message) {
   return new Error(formatErrorMessage(module, message));
@@ -44,13 +43,13 @@ async function atomicWriteFile(path, content) {
 function randHashGenerator(length = 12) {
   return Math.random().toString(36).substring(2, 2 + length).toUpperCase().padEnd(length, "0");
 }
-const loggerRef = ref();
+let loggerInstance;
 const initLogger = (debug) => {
-  loggerRef.value = useLogger("wpnuxt", { level: debug ? 4 : 3 });
-  return loggerRef.value;
+  loggerInstance = useLogger("wpnuxt", { level: debug ? 4 : 3 });
+  return loggerInstance;
 };
 function getLogger() {
-  return loggerRef.value;
+  return loggerInstance;
 }
 async function mergeQueries(nuxt, wpNuxtConfig, resolver) {
   const logger = getLogger();
@@ -70,7 +69,7 @@ async function mergeQueries(nuxt, wpNuxtConfig, resolver) {
   }
   if (existsSync(userQueryPath)) {
     logger.debug("Extending queries:", userQueryPath);
-    cpSync(userQueryPath, queryOutputPath, { recursive: true });
+    copyGraphqlFiles(userQueryPath, queryOutputPath);
   }
   logger.debug("Merged queries folder:", queryOutputPath);
   return queryOutputPath;
@@ -98,6 +97,20 @@ function findConflicts(userQueryPath, outputPath) {
   }
   return conflicts;
 }
+function copyGraphqlFiles(src, dest) {
+  const entries = readdirSync(src);
+  for (const entry of entries) {
+    const srcPath = join(src, entry);
+    const destPath = join(dest, entry);
+    const stat = statSync(srcPath);
+    if (stat.isDirectory()) {
+      mkdirSync(destPath, { recursive: true });
+      copyGraphqlFiles(srcPath, destPath);
+    } else if (entry.endsWith(".gql") || entry.endsWith(".graphql")) {
+      cpSync(srcPath, destPath);
+    }
+  }
+}
 
 const _parseDoc = async (doc) => {
   if (!doc || typeof doc !== "string" || doc.trim().length === 0) {
@@ -110,8 +123,12 @@ const _parseDoc = async (doc) => {
       if (!operationDefinition.name?.value) {
         throw createModuleError("core", "GraphQL operation is missing a name. All queries and mutations must have a name.");
       }
+      const name = operationDefinition.name.value.trim();
+      if (!/^[a-z_$][\w$]*$/i.test(name)) {
+        throw createModuleError("core", `Invalid GraphQL operation name "${name}". Operation names must be valid JavaScript identifiers (start with a letter, underscore, or $ and contain only letters, numbers, underscores, or $).`);
+      }
       const query = {
-        name: operationDefinition.name.value.trim(),
+        name,
         nodes: [],
         fragments: [],
         params: {},
@@ -281,7 +298,17 @@ async function prepareContext(ctx) {
       "  watch?: unknown[]",
       "  /** Transform function to alter the result */",
       "  transform?: (input: unknown) => unknown",
-      "  /** Additional options to pass to useAsyncGraphqlQuery */",
+      "  /** Enable client-side GraphQL caching. Default: true. Set to false for real-time data. */",
+      "  clientCache?: boolean",
+      "  /** Custom function to control when cached data should be used. */",
+      "  getCachedData?: (key: string, nuxtApp: unknown, ctx: unknown) => unknown",
+      "  /** Number of automatic retries on failure. Set to 0 or false to disable. Default: 0 (disabled) */",
+      "  retry?: number | false",
+      "  /** Base delay in milliseconds between retries (uses exponential backoff). Default: 1000 */",
+      "  retryDelay?: number",
+      "  /** Request timeout in milliseconds. Default: 0 (disabled). Set to e.g. 30000 for 30 seconds. */",
+      "  timeout?: number",
+      "  /** Additional options to pass to useAsyncData */",
       "  [key: string]: unknown",
       "}",
       "",
@@ -473,29 +500,31 @@ Check your wpNuxt.wordpressUrl configuration in nuxt.config.ts`
     );
   }
 }
-function patchWPGraphQLSchema(schemaPath) {
-  let schema = readFileSync(schemaPath, "utf-8");
-  const problematicInterfaces = [
-    "Connection",
-    "Edge",
-    "OneToOneConnection"
-  ];
-  problematicInterfaces.push("NodeWithEditorBlocks");
-  for (const iface of problematicInterfaces) {
-    schema = schema.replace(
-      new RegExp(`implements\\s+${iface}\\s*\\{`, "g"),
-      "{"
-    );
-    schema = schema.replace(
-      new RegExp(`implements\\s+${iface}\\s+&\\s+`, "g"),
-      "implements "
-    );
-    schema = schema.replace(
-      new RegExp(`\\s*&\\s*${iface}(?=\\s*[&{])`, "g"),
-      ""
+const PROBLEMATIC_INTERFACES = /* @__PURE__ */ new Set([
+  "Connection",
+  "Edge",
+  "OneToOneConnection",
+  "NodeWithEditorBlocks"
+]);
+function patchSchemaText(schemaText) {
+  const ast = parse(schemaText);
+  function filterInterfaces(node) {
+    if (!node.interfaces?.length) return void 0;
+    const filtered = node.interfaces.filter(
+      (iface) => !PROBLEMATIC_INTERFACES.has(iface.name.value)
     );
+    if (filtered.length === node.interfaces.length) return void 0;
+    return { ...node, interfaces: filtered };
   }
-  writeFileSync(schemaPath, schema);
+  const patched = visit(ast, {
+    ObjectTypeDefinition: filterInterfaces,
+    InterfaceTypeDefinition: filterInterfaces
+  });
+  return print(patched);
+}
+function patchWPGraphQLSchema(schemaPath) {
+  const schema = readFileSync(schemaPath, "utf-8");
+  writeFileSync(schemaPath, patchSchemaText(schema));
 }
 
 async function runInstall(nuxt) {
@@ -548,71 +577,31 @@ WPNUXT_WORDPRESS_URL=https://your-wordpress-site.com
 # Optional: Enable debug mode for verbose logging
 # WPNUXT_DEBUG=true
 `;
-function isInteractiveEnvironment() {
-  return !(process.env.CI === "true" || process.env.CI === "1" || process.env.VITEST === "true" || process.env.TEST === "true" || process.env.NODE_ENV === "test");
-}
 async function checkExistingEnvConfig(nuxt, envPath) {
   const nuxtConfig = nuxt.options;
   if (nuxtConfig.wpNuxt?.wordpressUrl) {
-    return { hasUrl: true, source: "nuxt.config.ts", envContent: "" };
+    return { hasUrl: true, source: "nuxt.config.ts" };
   }
   if (process.env.WPNUXT_WORDPRESS_URL) {
-    return { hasUrl: true, source: "WPNUXT_WORDPRESS_URL env var", envContent: "" };
+    return { hasUrl: true, source: "WPNUXT_WORDPRESS_URL env var" };
   }
   if (existsSync(envPath)) {
     const envContent = await readFile(envPath, "utf-8");
     if (/^WPNUXT_WORDPRESS_URL\s*=\s*.+/m.test(envContent)) {
-      return { hasUrl: true, source: ".env file", envContent };
+      return { hasUrl: true, source: ".env file" };
     }
-    return { hasUrl: false, envContent };
+    return { hasUrl: false };
   }
-  return { hasUrl: false, envContent: "" };
+  return { hasUrl: false };
 }
 async function setupEnvFiles(nuxt, logger) {
   const envPath = join(nuxt.options.rootDir, ".env");
   const envExamplePath = join(nuxt.options.rootDir, ".env.example");
   try {
     const existingConfig = await checkExistingEnvConfig(nuxt, envPath);
-    let envContent = existingConfig.envContent;
-    let urlConfigured = false;
-    if (existingConfig.hasUrl) {
+    const urlConfigured = existingConfig.hasUrl;
+    if (urlConfigured) {
       logger.debug(`WordPress URL already configured in ${existingConfig.source}`);
-      urlConfigured = true;
-    } else if (isInteractiveEnvironment()) {
-      consola.box({
-        title: "WPNuxt Setup",
-        message: "Configure your WordPress connection"
-      });
-      const wordpressUrl = await consola.prompt(
-        "What is your WordPress site URL?",
-        {
-          type: "text",
-          placeholder: "https://your-wordpress-site.com",
-          initial: ""
-        }
-      );
-      if (wordpressUrl && typeof wordpressUrl === "string" && wordpressUrl.trim()) {
-        const validation = validateWordPressUrl(wordpressUrl);
-        if (!validation.valid) {
-          logger.warn(`Invalid URL: ${validation.error}`);
-          logger.info("Skipped WordPress URL configuration. Add WPNUXT_WORDPRESS_URL to your .env file later.");
-        } else {
-          const envLine = `WPNUXT_WORDPRESS_URL=${validation.normalizedUrl}
-`;
-          if (envContent) {
-            envContent = envContent.trimEnd() + "\n\n" + envLine;
-          } else {
-            envContent = envLine;
-          }
-          await atomicWriteFile(envPath, envContent);
-          logger.success(`WordPress URL saved to .env: ${validation.normalizedUrl}`);
-          urlConfigured = true;
-        }
-      } else {
-        logger.info("Skipped WordPress URL configuration. Add WPNUXT_WORDPRESS_URL to your .env file later.");
-      }
-    } else {
-      logger.debug("Non-interactive environment detected, skipping WordPress URL prompt");
     }
     let exampleContent = "";
     let exampleUpdated = false;
@@ -714,65 +703,23 @@ async function setupGitignore(nuxt, logger) {
     return { name: "Gitignore", success: false, message };
   }
 }
-const QUERIES_README = `# Custom GraphQL Queries
-
-Place your custom \`.gql\` or \`.graphql\` files here to extend or override the default WPNuxt queries.
-
-## How it works
-
-1. Files here are merged with WPNuxt's default queries during build
-2. If a file has the same name as a default query, yours will override it
-3. New files will generate new composables automatically
-
-## Example
-
-Create a file \`CustomPosts.gql\`:
-
-\`\`\`graphql
-query CustomPosts($first: Int = 10) {
-  posts(first: $first) {
-    nodes {
-      id
-      title
-      date
-      # Add your custom fields here
-    }
-  }
-}
-\`\`\`
-
-This generates \`useCustomPosts()\` and \`useAsyncCustomPosts()\` composables.
-
-## Available Fragments
-
-You can use these fragments from WPNuxt's defaults:
-- \`...Post\` - Standard post fields
-- \`...Page\` - Standard page fields
-- \`...ContentNode\` - Common content fields
-- \`...FeaturedImage\` - Featured image with sizes
-
-## Documentation
-
-See https://wpnuxt.com/guide/custom-queries for more details.
-`;
 async function setupQueriesFolder(nuxt, logger) {
-  const queriesPath = join(nuxt.options.rootDir, "extend", "queries");
-  const readmePath = join(queriesPath, "README.md");
+  const queriesPath = join(nuxt.options.srcDir || nuxt.options.rootDir, "extend", "queries");
+  const displayPath = relative(nuxt.options.rootDir, queriesPath) || "extend/queries";
   try {
-    if (existsSync(readmePath)) {
-      logger.debug("extend/queries/ folder already exists");
+    if (existsSync(queriesPath)) {
+      logger.debug(`${displayPath}/ folder already exists`);
       return { name: "Queries folder", success: true, skipped: true };
     }
     await mkdir(queriesPath, { recursive: true });
-    await atomicWriteFile(readmePath, QUERIES_README);
     return {
       name: "Queries folder",
       success: true,
-      message: "Created extend/queries/ for custom GraphQL queries"
+      message: `Created ${displayPath}/ for custom GraphQL queries`
     };
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
-    logger.warn(`Failed to setup extend/queries/ folder: ${message}`);
+    logger.warn(`Failed to setup ${displayPath}/ folder: ${message}`);
     return { name: "Queries folder", success: false, message };
   }
 }
@@ -783,7 +730,7 @@ const module$1 = defineNuxtModule({
     version,
     configKey: "wpNuxt",
     compatibility: {
-      nuxt: ">=3.0.0"
+      nuxt: ">=3.17.0"
     }
   },
   defaults: {
@@ -882,29 +829,26 @@ const module$1 = defineNuxtModule({
       };
       logger.debug(`Configured WordPress uploads proxy: /wp-content/uploads/** \u2192 ${wpNuxtConfig.wordpressUrl}/wp-content/uploads/**`);
     }
-    nuxt.hook("modules:done", () => {
-      if (hasNuxtModule("@nuxt/image")) {
-        const imageConfig = nuxt.options.image || {};
-        const provider = process.env.NUXT_IMAGE_PROVIDER || imageConfig.provider || "ipx";
-        if (provider === "ipx") {
-          const wpHost = new URL(wpNuxtConfig.wordpressUrl).host;
-          const domains = imageConfig.domains || [];
-          if (!domains.includes(wpHost)) {
-            domains.push(wpHost);
-          }
-          imageConfig.domains = domains;
-          const alias = imageConfig.alias || {};
-          alias["/wp-content"] = `${wpNuxtConfig.wordpressUrl}/wp-content`;
-          imageConfig.alias = alias;
-          nuxt.options.image = imageConfig;
-          logger.debug(`Configured IPX for WordPress: alias /wp-content \u2192 ${wpNuxtConfig.wordpressUrl}/wp-content, domain '${wpHost}' added`);
+    {
+      const imageConfig = nuxt.options.image || {};
+      const provider = process.env.NUXT_IMAGE_PROVIDER || imageConfig.provider || "ipx";
+      if (provider === "ipx") {
+        const wpHost = new URL(wpNuxtConfig.wordpressUrl).host;
+        const domains = imageConfig.domains || [];
+        if (!domains.includes(wpHost)) {
+          domains.push(wpHost);
         }
+        imageConfig.domains = domains;
+        const alias = imageConfig.alias || {};
+        alias["/wp-content"] = `${wpNuxtConfig.wordpressUrl}/wp-content`;
+        imageConfig.alias = alias;
+        nuxt.options.image = imageConfig;
+        logger.debug(`Configured IPX for WordPress: alias /wp-content \u2192 ${wpNuxtConfig.wordpressUrl}/wp-content, domain '${wpHost}' added`);
       }
-    });
+    }
     configureVercelSettings(nuxt, logger);
     addImports([
       { name: "useWPContent", as: "useWPContent", from: resolver.resolve("./runtime/composables/useWPContent") },
-      { name: "useAsyncWPContent", as: "useAsyncWPContent", from: resolver.resolve("./runtime/composables/useWPContent") },
       { name: "getRelativeImagePath", as: "getRelativeImagePath", from: resolver.resolve("./runtime/util/images") },
       { name: "isInternalLink", as: "isInternalLink", from: resolver.resolve("./runtime/util/links") },
       { name: "toRelativePath", as: "toRelativePath", from: resolver.resolve("./runtime/util/links") },
@@ -971,38 +915,13 @@ async function loadConfig(options, nuxt) {
     if (nuxt.options._prepare) {
       return null;
     }
-    if (nuxt.options.dev && process.stdout.isTTY) {
-      const wordpressUrl = await consola.prompt(
-        "Enter your WordPress site URL (must have WPGraphQL installed):",
-        { type: "text", placeholder: "https://your-wordpress-site.com" }
-      );
-      if (wordpressUrl && typeof wordpressUrl === "string" && wordpressUrl.trim()) {
-        const validation = validateWordPressUrl(wordpressUrl);
-        if (validation.valid && validation.normalizedUrl) {
-          config.wordpressUrl = validation.normalizedUrl;
-          const envPath = join(nuxt.options.rootDir, ".env");
-          const envLine = `WPNUXT_WORDPRESS_URL=${validation.normalizedUrl}
-`;
-          if (existsSync(envPath)) {
-            const existing = await readFile(envPath, "utf-8");
-            await atomicWriteFile(envPath, existing.trimEnd() + "\n" + envLine);
-          } else {
-            await atomicWriteFile(envPath, envLine);
-          }
-          consola.success(`WordPress URL saved to .env: ${validation.normalizedUrl}`);
-        } else {
-          throw createModuleError("core", `Invalid WordPress URL: ${validation.error}`);
-        }
-      } else {
-        throw createModuleError("core", "WordPress URL is required. Set it in nuxt.config.ts or via WPNUXT_WORDPRESS_URL environment variable.");
-      }
-    } else {
-      throw createModuleError("core", "WordPress URL is required. Set it in nuxt.config.ts or via WPNUXT_WORDPRESS_URL environment variable.");
-    }
+    throw createModuleError("core", "WordPress URL is required. Set it in nuxt.config.ts or via WPNUXT_WORDPRESS_URL environment variable.");
   }
-  if (config.wordpressUrl.endsWith("/")) {
-    throw createModuleError("core", `WordPress URL should not have a trailing slash: ${config.wordpressUrl}`);
+  const validation = validateWordPressUrl(config.wordpressUrl);
+  if (!validation.valid) {
+    throw createModuleError("core", `Invalid WordPress URL: ${validation.error}`);
   }
+  config.wordpressUrl = validation.normalizedUrl;
   nuxt.options.runtimeConfig.public.wordpressUrl = config.wordpressUrl;
   nuxt.options.runtimeConfig.public.wpNuxt = {
     wordpressUrl: config.wordpressUrl,
@@ -1018,53 +937,7 @@ async function loadConfig(options, nuxt) {
   };
   return config;
 }
-const SERVER_OPTIONS_TEMPLATE = `import { defineGraphqlServerOptions } from '@wpnuxt/core/server-options'
-import { getHeader, getCookie } from 'h3'
-import { useRuntimeConfig } from '#imports'
-
-/**
- * WPNuxt default server options for nuxt-graphql-middleware.
- *
- * This enables:
- * - Cookie forwarding for WordPress preview mode
- * - Authorization header forwarding for authenticated requests
- * - Auth token from cookie for @wpnuxt/auth
- * - Consistent error logging
- *
- * Users can customize by creating their own server/graphqlMiddleware.serverOptions.ts
- */
-export default defineGraphqlServerOptions({
-  async serverFetchOptions(event, _operation, _operationName, _context) {
-    // Get auth token from Authorization header or from cookie
-    let authorization = getHeader(event, 'authorization') || ''
-
-    // If no Authorization header, check for auth token in cookie (@wpnuxt/auth)
-    if (!authorization) {
-      const config = useRuntimeConfig().public.wpNuxtAuth as { cookieName?: string } | undefined
-      const cookieName = config?.cookieName || 'wpnuxt-auth-token'
-      const authToken = getCookie(event, cookieName)
-      if (authToken) {
-        authorization = \`Bearer \${authToken}\`
-      }
-    }
-
-    return {
-      headers: {
-        // Forward WordPress auth cookies for previews
-        Cookie: getHeader(event, 'cookie') || '',
-        // Forward authorization header or token from cookie
-        Authorization: authorization
-      }
-    }
-  },
-
-  async onServerError(event, error, _operation, operationName) {
-    const url = event.node.req.url || 'unknown'
-    console.error(\`[WPNuxt] GraphQL error in \${operationName} (\${url}):\`, error.message)
-  }
-})
-`;
-async function setupServerOptions(nuxt, _resolver, logger) {
+async function setupServerOptions(nuxt, resolver, logger) {
   const serverDir = nuxt.options.serverDir;
   const targetPath = join(serverDir, "graphqlMiddleware.serverOptions.ts");
   if (existsSync(targetPath)) {
@@ -1074,39 +947,14 @@ async function setupServerOptions(nuxt, _resolver, logger) {
   if (!existsSync(serverDir)) {
     await mkdir(serverDir, { recursive: true });
   }
-  await writeFile(targetPath, SERVER_OPTIONS_TEMPLATE);
+  const template = readFileSync(
+    resolver.resolve("./runtime/server/graphqlMiddleware.serverOptions.ts"),
+    "utf-8"
+  );
+  await writeFile(targetPath, template);
   logger.debug("Created graphqlMiddleware.serverOptions.ts with WPNuxt defaults (cookie/auth forwarding)");
 }
-const CLIENT_OPTIONS_TEMPLATE = `import { defineGraphqlClientOptions } from '@wpnuxt/core/client-options'
-import { useRoute } from '#imports'
-
-/**
- * WPNuxt default client options for nuxt-graphql-middleware.
- *
- * This enables passing client context to the server for:
- * - Preview mode (passes preview flag and token from URL query params)
- *
- * The context is available in serverFetchOptions via context.client
- * All values must be strings (nuxt-graphql-middleware requirement)
- *
- * Users can customize by creating their own app/graphqlMiddleware.clientOptions.ts
- */
-export default defineGraphqlClientOptions<{
-  preview?: string
-  previewToken?: string
-}>({
-  buildClientContext() {
-    const route = useRoute()
-
-    return {
-      // Context values must be strings - use 'true'/'false' instead of boolean
-      preview: route.query.preview === 'true' ? 'true' : undefined,
-      previewToken: route.query.token as string | undefined
-    }
-  }
-})
-`;
-async function setupClientOptions(nuxt, _resolver, logger) {
+async function setupClientOptions(nuxt, resolver, logger) {
   const appDir = nuxt.options.dir.app;
   const targetPath = join(appDir, "graphqlMiddleware.clientOptions.ts");
   if (existsSync(targetPath)) {
@@ -1116,11 +964,15 @@ async function setupClientOptions(nuxt, _resolver, logger) {
   if (!existsSync(appDir)) {
     await mkdir(appDir, { recursive: true });
   }
-  await writeFile(targetPath, CLIENT_OPTIONS_TEMPLATE);
+  const template = readFileSync(
+    resolver.resolve("./runtime/app/graphqlMiddleware.clientOptions.ts"),
+    "utf-8"
+  );
+  await writeFile(targetPath, template);
   logger.debug("Created graphqlMiddleware.clientOptions.ts with WPNuxt defaults (preview mode support)");
 }
 function configureTrailingSlash(nuxt, logger) {
-  const handlerPath = join(nuxt.options.buildDir, "wpnuxt", "trailing-slash-handler.ts");
+  const handlerPath = join(nuxt.options.buildDir, "wpnuxt", "trailing-slash-handler.ts").replace(/\\/g, "/");
   const handlerCode = `import { defineEventHandler, sendRedirect, getRequestURL } from 'h3'
 
 export default defineEventHandler((event) => {

package/dist/runtime/app/graphqlMiddleware.clientOptions.js

@@ -1,4 +1,4 @@
-import { defineGraphqlClientOptions } from "nuxt-graphql-middleware/client-options";
+import { defineGraphqlClientOptions } from "@wpnuxt/core/client-options";
 import { useRoute } from "#imports";
 export default defineGraphqlClientOptions({
   buildClientContext() {

package/dist/runtime/composables/usePrevNextPost.js

@@ -1,6 +1,6 @@
 import { useWPContent } from "./useWPContent.js";
-export async function usePrevNextPost(currentSlug) {
-  const { data, execute } = useWPContent("Posts", ["posts", "nodes"], false, { limit: 100 });
+export async function usePrevNextPost(currentSlug, limit = 1e3) {
+  const { data, execute } = useWPContent("Posts", ["posts", "nodes"], false, { limit });
   await execute();
   const allPosts = data.value || [];
   if (!allPosts.length) {

package/dist/runtime/plugins/sanitizeHtml.js

@@ -1,29 +1,35 @@
 import { defineNuxtPlugin } from "#imports";
 export default defineNuxtPlugin((nuxtApp) => {
-  let sanitize;
   if (import.meta.server) {
-    sanitize = (html) => html;
-  } else {
-    let purify = null;
-    sanitize = (html) => {
-      if (purify) {
-        return purify.sanitize(html);
+    nuxtApp.vueApp.directive("sanitize-html", {
+      getSSRProps(binding) {
+        return { innerHTML: binding.value };
       }
-      return html;
-    };
-    import("dompurify").then((DOMPurify) => {
-      purify = DOMPurify.default(window);
     });
+    return;
+  }
+  let purify = null;
+  const purifyReady = import("dompurify").then((DOMPurify) => {
+    purify = DOMPurify.default(window);
+  });
+  function setSanitizedHtml(el, html) {
+    if (purify) {
+      el.innerHTML = purify.sanitize(html);
+    } else {
+      purifyReady.then(() => {
+        el.innerHTML = purify.sanitize(html);
+      });
+    }
   }
   nuxtApp.vueApp.directive("sanitize-html", {
     created(el, binding) {
-      el.innerHTML = sanitize(binding.value);
+      setSanitizedHtml(el, binding.value);
     },
     updated(el, binding) {
-      el.innerHTML = sanitize(binding.value);
+      setSanitizedHtml(el, binding.value);
     },
     getSSRProps(binding) {
-      return { innerHTML: sanitize(binding.value) };
+      return { innerHTML: binding.value };
     }
   });
 });

package/dist/runtime/queries/Pages.gql

@@ -10,8 +10,8 @@ query PageByUri($uri: ID!) {
     ...Page
   }
 }
-query PageById($id: ID!) {
-  page(id: $id, idType: DATABASE_ID, asPreview: true) {
+query PageById($id: ID!, $asPreview: Boolean = false) {
+  page(id: $id, idType: DATABASE_ID, asPreview: $asPreview) {
     ...Page
   }
 }

package/dist/runtime/queries/fragments/MediaItem.fragment.gql

@@ -29,7 +29,21 @@ fragment MediaItem on MediaItem {
   isTermNode
   # lastEditedBy
   link
-  # mediaDetails
+  mediaDetails {
+    file
+    filePath
+    height
+    width
+    sizes {
+      file
+      fileSize
+      height
+      mimeType
+      name
+      sourceUrl
+      width
+    }
+  }
   mediaItemId
   mediaItemUrl
   mediaType

package/dist/runtime/server/graphqlMiddleware.serverOptions.js

@@ -1,13 +1,23 @@
-import { defineGraphqlServerOptions } from "nuxt-graphql-middleware/server-options";
-import { getHeader } from "h3";
+import { defineGraphqlServerOptions } from "@wpnuxt/core/server-options";
+import { getHeader, getCookie } from "h3";
+import { useRuntimeConfig } from "#imports";
 export default defineGraphqlServerOptions({
   async serverFetchOptions(event, _operation, _operationName, _context) {
+    let authorization = getHeader(event, "authorization") || "";
+    if (!authorization) {
+      const config = useRuntimeConfig().public.wpNuxtAuth;
+      const cookieName = config?.cookieName || "wpnuxt-auth-token";
+      const authToken = getCookie(event, cookieName);
+      if (authToken) {
+        authorization = `Bearer ${authToken}`;
+      }
+    }
     return {
       headers: {
         // Forward WordPress auth cookies for previews
         Cookie: getHeader(event, "cookie") || "",
-        // Forward authorization header if present
-        Authorization: getHeader(event, "authorization") || ""
+        // Forward authorization header or token from cookie
+        Authorization: authorization
       }
     };
   },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpnuxt/core",
-  "version": "2.0.0-beta.2",
+  "version": "2.0.0-beta.4",
   "description": "Nuxt module for WordPress integration via GraphQL (WPGraphQL)",
   "keywords": [
     "nuxt",
@@ -55,7 +55,7 @@
     "scule": "^1.3.0"
   },
   "devDependencies": {
-    "@nuxt/devtools": "^3.2.0",
+    "@nuxt/devtools": "^3.2.1",
     "@nuxt/module-builder": "^1.0.2",
     "@nuxt/schema": "4.3.1",
     "@nuxt/test-utils": "^4.0.0",
@@ -65,7 +65,7 @@
     "vue-tsc": "^3.2.3"
   },
   "peerDependencies": {
-    "nuxt": "^4.0.0"
+    "nuxt": ">=3.17.0"
   },
   "scripts": {
     "build": "nuxt-module-build build",
@@ -73,7 +73,6 @@
     "lint": "eslint src",
     "test": "vitest run",
     "test:watch": "vitest watch",
-    "typecheck": "vue-tsc --noEmit",
-    "clean": "rm -rf dist .nuxt node_modules"
+    "typecheck": "vue-tsc --noEmit"
   }
 }