@wpnuxt/core 2.0.0-alpha.7 → 2.0.0-alpha.9

package/dist/module.d.mts

@@ -30,6 +30,11 @@ interface WPNuxtConfig {
          * @default '.queries/'
          */
         mergedOutputFolder: string;
+        /**
+         * Whether to warn when a user query file overrides a default query file
+         * @default true
+         */
+        warnOnOverride?: boolean;
     };
     /**
      * Whether to download the schema from the WordPress site and save it to disk

package/dist/module.d.ts

@@ -30,6 +30,11 @@ interface WPNuxtConfig {
          * @default '.queries/'
          */
         mergedOutputFolder: string;
+        /**
+         * Whether to warn when a user query file overrides a default query file
+         * @default true
+         */
+        warnOnOverride?: boolean;
     };
     /**
      * Whether to download the schema from the WordPress site and save it to disk

package/dist/module.json

@@ -1,10 +1,10 @@
 {
   "name": "@wpnuxt/core",
+  "version": "2.0.0-alpha.8",
   "configKey": "wpNuxt",
   "compatibility": {
     "nuxt": ">=3.0.0"
   },
-  "version": "2.0.0-alpha.6",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,12 +1,15 @@
 import { defu } from 'defu';
-import { promises, cpSync, existsSync, statSync, readFileSync, writeFileSync } from 'node:fs';
-import { mkdir, writeFile } from 'node:fs/promises';
-import { join } from 'node:path';
+import { promises, cpSync, existsSync, readdirSync, statSync, 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, addImports, addComponentsDir, addTemplate, addTypeTemplate, hasNuxtModule, installModule } from '@nuxt/kit';
 import { upperFirst } from 'scule';
 import { ref } from 'vue';
 import { parse, GraphQLError } from 'graphql';
 import { execSync } from 'node:child_process';
+import { consola } from 'consola';
+
+const version = "2.0.0-alpha.8";
 
 function createModuleError(module, message) {
   return new Error(formatErrorMessage(module, message));
@@ -15,6 +18,29 @@ function formatErrorMessage(module, message) {
   return `[wpnuxt:${module}] ${message}`;
 }
 
+function validateWordPressUrl(url) {
+  if (!url?.trim()) {
+    return { valid: false, error: "URL cannot be empty" };
+  }
+  let normalizedUrl = url.trim();
+  if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://")) {
+    normalizedUrl = `https://${normalizedUrl}`;
+  }
+  try {
+    const parsed = new URL(normalizedUrl);
+    if (!["http:", "https:"].includes(parsed.protocol)) {
+      return { valid: false, error: "URL must use http or https protocol" };
+    }
+    return { valid: true, normalizedUrl: normalizedUrl.replace(/\/+$/, "") };
+  } catch {
+    return { valid: false, error: "Invalid URL format" };
+  }
+}
+async function atomicWriteFile(path, content) {
+  const tempPath = `${path}.${Date.now()}.tmp`;
+  await writeFile(tempPath, content, "utf-8");
+  await rename(tempPath, path);
+}
 function randHashGenerator(length = 12) {
   return Math.random().toString(36).substring(2, 2 + length).toUpperCase().padEnd(length, "0");
 }
@@ -35,6 +61,13 @@ async function mergeQueries(nuxt, wpNuxtConfig, resolver) {
   const defaultQueriesPath = resolver.resolve("./runtime/queries");
   await promises.rm(queryOutputPath, { recursive: true, force: true });
   cpSync(defaultQueriesPath, queryOutputPath, { recursive: true });
+  const conflicts = findConflicts(userQueryPath, queryOutputPath);
+  if (conflicts.length && wpNuxtConfig.queries.warnOnOverride) {
+    logger.warn("The following user query files will override default queries:");
+    for (const file of conflicts) {
+      logger.warn(` - ${file}`);
+    }
+  }
   if (existsSync(userQueryPath)) {
     logger.debug("Extending queries:", userQueryPath);
     cpSync(userQueryPath, queryOutputPath, { recursive: true });
@@ -42,6 +75,29 @@ async function mergeQueries(nuxt, wpNuxtConfig, resolver) {
   logger.debug("Merged queries folder:", queryOutputPath);
   return queryOutputPath;
 }
+function findConflicts(userQueryPath, outputPath) {
+  const conflicts = [];
+  function walk(dir) {
+    const entries = readdirSync(dir);
+    for (const entry of entries) {
+      const fullPath = join(dir, entry);
+      const stat = statSync(fullPath);
+      if (stat.isDirectory()) {
+        walk(fullPath);
+      } else if (stat.isFile()) {
+        const rel = relative(userQueryPath, fullPath);
+        const target = join(outputPath, rel);
+        if (existsSync(target)) {
+          conflicts.push(rel);
+        }
+      }
+    }
+  }
+  if (existsSync(userQueryPath)) {
+    walk(userQueryPath);
+  }
+  return conflicts;
+}
 
 const _parseDoc = async (doc) => {
   if (!doc || typeof doc !== "string" || doc.trim().length === 0) {
@@ -143,8 +199,21 @@ async function prepareContext(ctx) {
   const mutationFnName = (fn) => `useMutation${upperFirst(fn)}`;
   const formatNodes = (nodes) => nodes?.map((n) => `'${n}'`).join(",") ?? "";
   const getFragmentType = (q) => {
-    const fragmentSuffix = q.fragments?.length && q.nodes?.includes("nodes") ? "[]" : "";
-    return q.fragments?.length ? q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ") : "any";
+    if (q.fragments?.length) {
+      const fragmentSuffix = q.nodes?.includes("nodes") ? "[]" : "";
+      return q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ");
+    }
+    if (q.nodes?.length) {
+      let typePath = `${q.name}RootQuery`;
+      for (const node of q.nodes) {
+        typePath = `NonNullable<${typePath}>['${node}']`;
+      }
+      if (q.nodes.includes("nodes")) {
+        typePath = `${typePath}[number]`;
+      }
+      return typePath;
+    }
+    return `${q.name}RootQuery`;
   };
   const queryFnExp = (q, typed = false) => {
     const functionName = fnName(q.name);
@@ -161,19 +230,34 @@ async function prepareContext(ctx) {
     return `  export const ${functionName}: (variables: ${m.name}MutationVariables, options?: WPMutationOptions) => Promise<WPMutationResult<${m.name}Mutation>>`;
   };
   ctx.generateImports = () => {
+    const lines = [];
     const imports = [];
+    if (queries.length > 0) {
+      imports.push("useWPContent");
+    }
+    if (mutations.length > 0) {
+      imports.push("useGraphqlMutation");
+    }
+    if (imports.length > 0) {
+      lines.push(`import { ${imports.join(", ")} } from '#imports'`);
+      lines.push("");
+    }
     queries.forEach((f) => {
-      imports.push(queryFnExp(f, false));
+      lines.push(queryFnExp(f, false));
     });
     mutations.forEach((m) => {
-      imports.push(mutationFnExp(m, false));
+      lines.push(mutationFnExp(m, false));
     });
-    return imports.join("\n");
+    return lines.join("\n");
   };
   const typeSet = /* @__PURE__ */ new Set();
   queries.forEach((o) => {
     typeSet.add(`${o.name}QueryVariables`);
-    o.fragments?.forEach((f) => typeSet.add(`${f}Fragment`));
+    if (o.fragments?.length) {
+      o.fragments.forEach((f) => typeSet.add(`${f}Fragment`));
+    } else {
+      typeSet.add(`${o.name}RootQuery`);
+    }
   });
   mutations.forEach((m) => {
     typeSet.add(`${m.name}MutationVariables`);
@@ -404,9 +488,289 @@ function patchWPGraphQLSchema(schemaPath) {
   writeFileSync(schemaPath, schema);
 }
 
+async function runInstall(nuxt) {
+  const logger = useLogger("wpnuxt", {
+    level: process.env.WPNUXT_DEBUG === "true" ? 4 : 3
+  });
+  const results = [];
+  results.push(await setupEnvFiles(nuxt, logger));
+  const parallel = await Promise.all([
+    setupMcpConfig(nuxt, logger),
+    setupGitignore(nuxt, logger),
+    setupQueriesFolder(nuxt, logger)
+  ]);
+  results.push(...parallel);
+  displayInstallSummary(results, logger);
+}
+function displayInstallSummary(results, logger) {
+  const successes = results.filter((r) => r.success && !r.skipped);
+  const skipped = results.filter((r) => r.skipped);
+  const failures = results.filter((r) => !r.success);
+  if (successes.length > 0) {
+    const lines = [
+      ...successes.map((r) => `\u2713 ${r.message || r.name}`),
+      "",
+      "Next steps:",
+      "  1. Ensure WPGraphQL is installed on WordPress",
+      "  2. Run `pnpm dev` to start development",
+      "",
+      "Docs: https://wpnuxt.com"
+    ];
+    consola.box({
+      title: "WPNuxt Setup Complete",
+      message: lines.join("\n")
+    });
+  }
+  if (skipped.length > 0) {
+    logger.debug(`Skipped (already configured): ${skipped.map((r) => r.name).join(", ")}`);
+  }
+  if (failures.length > 0) {
+    logger.debug(`Failed: ${failures.map((r) => r.name).join(", ")}`);
+  }
+}
+const ENV_EXAMPLE_CONTENT = `# WPNuxt Configuration
+# Required: Your WordPress site URL (must have WPGraphQL plugin installed)
+WPNUXT_WORDPRESS_URL=https://your-wordpress-site.com
+
+# Optional: Custom GraphQL endpoint (default: /graphql)
+# WPNUXT_GRAPHQL_ENDPOINT=/graphql
+
+# 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: "" };
+  }
+  if (process.env.WPNUXT_WORDPRESS_URL) {
+    return { hasUrl: true, source: "WPNUXT_WORDPRESS_URL env var", envContent: "" };
+  }
+  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: false, envContent };
+  }
+  return { hasUrl: false, envContent: "" };
+}
+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) {
+      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;
+    if (existsSync(envExamplePath)) {
+      exampleContent = await readFile(envExamplePath, "utf-8");
+      if (exampleContent.includes("WPNUXT_WORDPRESS_URL")) {
+        logger.debug(".env.example already includes WPNuxt configuration");
+      } else {
+        exampleContent = exampleContent.trimEnd() + "\n\n" + ENV_EXAMPLE_CONTENT;
+        await atomicWriteFile(envExamplePath, exampleContent);
+        exampleUpdated = true;
+      }
+    } else {
+      exampleContent = ENV_EXAMPLE_CONTENT;
+      await atomicWriteFile(envExamplePath, exampleContent);
+      exampleUpdated = true;
+    }
+    if (urlConfigured && exampleUpdated) {
+      return {
+        name: "Environment files",
+        success: true,
+        message: "Configured .env with WordPress URL"
+      };
+    } else if (urlConfigured) {
+      return { name: "Environment files", success: true, skipped: true };
+    } else if (exampleUpdated) {
+      return {
+        name: "Environment files",
+        success: true,
+        message: "Created .env.example template"
+      };
+    } else {
+      return { name: "Environment files", success: true, skipped: true };
+    }
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to setup environment files: ${message}`);
+    return { name: "Environment files", success: false, message };
+  }
+}
+const MCP_CONFIG = {
+  wpnuxt: {
+    type: "http",
+    url: "https://wpnuxt.com/mcp"
+  }
+};
+async function setupMcpConfig(nuxt, logger) {
+  const mcpPath = join(nuxt.options.rootDir, ".mcp.json");
+  try {
+    let config = { mcpServers: {} };
+    if (existsSync(mcpPath)) {
+      const content = await readFile(mcpPath, "utf-8");
+      config = JSON.parse(content);
+      config.mcpServers = config.mcpServers || {};
+      if (config.mcpServers.wpnuxt) {
+        logger.debug("MCP config already includes wpnuxt server");
+        return { name: "MCP config", success: true, skipped: true };
+      }
+    }
+    config.mcpServers = {
+      ...config.mcpServers,
+      ...MCP_CONFIG
+    };
+    await atomicWriteFile(mcpPath, JSON.stringify(config, null, 2) + "\n");
+    return {
+      name: "MCP config",
+      success: true,
+      message: "Created .mcp.json with WPNuxt MCP server"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to setup MCP configuration: ${message}`);
+    return { name: "MCP config", success: false, message };
+  }
+}
+async function setupGitignore(nuxt, logger) {
+  const gitignorePath = join(nuxt.options.rootDir, ".gitignore");
+  try {
+    let content = "";
+    if (existsSync(gitignorePath)) {
+      content = await readFile(gitignorePath, "utf-8");
+      if (content.includes(".queries")) {
+        logger.debug(".gitignore already includes .queries");
+        return { name: "Gitignore", success: true, skipped: true };
+      }
+      content = content.trimEnd() + "\n\n# WPNuxt generated files\n.queries/\n";
+    } else {
+      content = "# WPNuxt generated files\n.queries/\n";
+    }
+    await atomicWriteFile(gitignorePath, content);
+    return {
+      name: "Gitignore",
+      success: true,
+      message: "Added .queries/ to .gitignore"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to setup .gitignore: ${message}`);
+    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");
+  try {
+    if (existsSync(readmePath)) {
+      logger.debug("extend/queries/ 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"
+    };
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    logger.warn(`Failed to setup extend/queries/ folder: ${message}`);
+    return { name: "Queries folder", success: false, message };
+  }
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "@wpnuxt/core",
+    version,
     configKey: "wpNuxt",
     compatibility: {
       nuxt: ">=3.0.0"
@@ -417,7 +781,8 @@ const module$1 = defineNuxtModule({
     graphqlEndpoint: "/graphql",
     queries: {
       extendFolder: "extend/queries/",
-      mergedOutputFolder: ".queries/"
+      mergedOutputFolder: ".queries/",
+      warnOnOverride: true
     },
     downloadSchema: true,
     debug: false,
@@ -437,6 +802,7 @@ const module$1 = defineNuxtModule({
     nuxt.options.runtimeConfig.public.buildHash = randHashGenerator();
     addPlugin(resolver.resolve("./runtime/plugins/graphqlConfig"));
     addPlugin(resolver.resolve("./runtime/plugins/graphqlErrors"));
+    configureTrailingSlash(nuxt, logger);
     const mergedQueriesFolder = await mergeQueries(nuxt, wpNuxtConfig, resolver);
     await setupServerOptions(nuxt, resolver, logger);
     await setupClientOptions(nuxt, resolver, logger);
@@ -477,8 +843,10 @@ const module$1 = defineNuxtModule({
     });
     if (wpNuxtConfig.cache?.enabled !== false) {
       const maxAge = wpNuxtConfig.cache?.maxAge ?? 300;
-      nuxt.options.nitro.routeRules = nuxt.options.nitro.routeRules || {};
-      nuxt.options.nitro.routeRules["/api/wpnuxt/**"] = {
+      const nitroOptions = nuxt.options;
+      nitroOptions.nitro = nitroOptions.nitro || {};
+      nitroOptions.nitro.routeRules = nitroOptions.nitro.routeRules || {};
+      nitroOptions.nitro.routeRules["/api/wpnuxt/**"] = {
         cache: {
           maxAge,
           swr: wpNuxtConfig.cache?.swr !== false
@@ -510,10 +878,12 @@ const module$1 = defineNuxtModule({
     nuxt.options.alias["#wpnuxt"] = resolver.resolve(nuxt.options.buildDir, "wpnuxt");
     nuxt.options.alias["#wpnuxt/*"] = resolver.resolve(nuxt.options.buildDir, "wpnuxt", "*");
     nuxt.options.alias["#wpnuxt/types"] = resolver.resolve("./types");
-    nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
-    nuxt.options.nitro.alias["#wpnuxt/types"] = resolver.resolve("./types");
-    nuxt.options.nitro.externals = nuxt.options.nitro.externals || {};
-    nuxt.options.nitro.externals.inline = nuxt.options.nitro.externals.inline || [];
+    const nitroOpts = nuxt.options;
+    nitroOpts.nitro = nitroOpts.nitro || {};
+    nitroOpts.nitro.alias = nitroOpts.nitro.alias || {};
+    nitroOpts.nitro.alias["#wpnuxt/types"] = resolver.resolve("./types");
+    nitroOpts.nitro.externals = nitroOpts.nitro.externals || {};
+    nitroOpts.nitro.externals.inline = nitroOpts.nitro.externals.inline || [];
     addTemplate({
       write: true,
       filename: "wpnuxt/index.mjs",
@@ -529,6 +899,9 @@ const module$1 = defineNuxtModule({
     });
     logger.trace("Finished generating composables");
     logger.info(`WPNuxt module loaded in ${(/* @__PURE__ */ new Date()).getTime() - startTime}ms`);
+  },
+  async onInstall(nuxt) {
+    await runInstall(nuxt);
   }
 });
 function loadConfig(options, nuxt) {
@@ -661,18 +1034,63 @@ async function setupClientOptions(nuxt, _resolver, logger) {
   await writeFile(targetPath, CLIENT_OPTIONS_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 handlerCode = `import { defineEventHandler, sendRedirect, getRequestURL } from 'h3'
+
+export default defineEventHandler((event) => {
+  const url = getRequestURL(event)
+  const path = url.pathname
+
+  // Skip if:
+  // - Already has trailing slash
+  // - Is root path
+  // - Is an API route
+  // - Has a file extension (likely a static file)
+  // - Is a Nuxt internal route (_nuxt, __nuxt)
+  if (
+    path.endsWith('/') ||
+    path === '' ||
+    path.startsWith('/api/') ||
+    path.startsWith('/_nuxt/') ||
+    path.startsWith('/__nuxt') ||
+    path.includes('.')
+  ) {
+    return
+  }
+
+  // Redirect to trailing slash version
+  return sendRedirect(event, path + '/' + url.search, 301)
+})
+`;
+  nuxt.hook("build:before", async () => {
+    await mkdir(dirname(handlerPath), { recursive: true });
+    await writeFile(handlerPath, handlerCode);
+    logger.debug("Created trailing slash handler at " + handlerPath);
+  });
+  nuxt.hook("nitro:config", (nitroConfig) => {
+    nitroConfig.handlers = nitroConfig.handlers || [];
+    nitroConfig.handlers.unshift({
+      route: "/**",
+      handler: handlerPath
+    });
+  });
+  logger.debug("Configured trailing slash handling for WordPress URI compatibility");
+}
 function configureVercelSettings(nuxt, logger) {
-  const isVercel = process.env.VERCEL === "1" || nuxt.options.nitro.preset === "vercel";
+  const opts = nuxt.options;
+  opts.nitro = opts.nitro || {};
+  const isVercel = process.env.VERCEL === "1" || opts.nitro.preset === "vercel";
   if (isVercel) {
     logger.debug("Vercel deployment detected, applying recommended settings");
-    nuxt.options.nitro.future = nuxt.options.nitro.future || {};
-    if (nuxt.options.nitro.future.nativeSWR === void 0) {
-      nuxt.options.nitro.future.nativeSWR = true;
+    opts.nitro.future = opts.nitro.future || {};
+    if (opts.nitro.future.nativeSWR === void 0) {
+      opts.nitro.future.nativeSWR = true;
       logger.debug("Enabled nitro.future.nativeSWR for Vercel ISR compatibility");
     }
-    nuxt.options.routeRules = nuxt.options.routeRules || {};
-    if (!nuxt.options.routeRules["/**"]) {
-      nuxt.options.routeRules["/**"] = { ssr: true };
+    opts.routeRules = opts.routeRules || {};
+    if (!opts.routeRules["/**"]) {
+      opts.routeRules["/**"] = { ssr: true };
       logger.debug("Enabled SSR for all routes (routeRules['/**'] = { ssr: true })");
     }
   }

package/dist/runtime/composables/useWPContent.js

@@ -1,4 +1,4 @@
-import { getRelativeImagePath } from "../util/images.js";
+import { transformData, normalizeUriParam } from "../util/content.js";
 import { computed, ref, watch as vueWatch, useAsyncGraphqlQuery } from "#imports";
 export const useWPContent = (queryName, nodes, fixImagePaths, params, options) => {
   const {
@@ -9,6 +9,7 @@ export const useWPContent = (queryName, nodes, fixImagePaths, params, options) =
     timeout: timeoutOption,
     ...restOptions
   } = options ?? {};
+  const normalizedParams = normalizeUriParam(params);
   const maxRetries = retryOption === false ? 0 : retryOption ?? 0;
   const baseRetryDelay = retryDelayOption ?? 1e3;
   const retryCount = ref(0);
@@ -50,7 +51,7 @@ export const useWPContent = (queryName, nodes, fixImagePaths, params, options) =
   };
   const { data, pending, refresh, execute, clear, error, status } = useAsyncGraphqlQuery(
     String(queryName),
-    params ?? {},
+    normalizedParams ?? {},
     asyncDataOptions
   );
   const transformError = ref(null);
@@ -115,25 +116,3 @@ export const useWPContent = (queryName, nodes, fixImagePaths, params, options) =
     isRetrying
   };
 };
-const transformData = (data, nodes, fixImagePaths) => {
-  const transformedData = findData(data, nodes);
-  if (fixImagePaths && transformedData && typeof transformedData === "object" && "featuredImage" in transformedData) {
-    const featuredImage = transformedData.featuredImage;
-    if (featuredImage && typeof featuredImage === "object" && "node" in featuredImage) {
-      const node = featuredImage.node;
-      if (node && typeof node === "object" && "sourceUrl" in node && typeof node.sourceUrl === "string") {
-        node.relativePath = getRelativeImagePath(node.sourceUrl);
-      }
-    }
-  }
-  return transformedData;
-};
-const findData = (data, nodes) => {
-  if (nodes.length === 0) return data;
-  return nodes.reduce((acc, node) => {
-    if (acc && typeof acc === "object" && node in acc) {
-      return acc[node];
-    }
-    return void 0;
-  }, data);
-};

package/dist/runtime/types/stub.d.ts

@@ -4,23 +4,44 @@
  * Actual types are generated at runtime in consuming applications.
  */
 
-/* eslint-disable @typescript-eslint/no-explicit-any */
+import type { Ref, ComputedRef, WatchSource, WatchCallback, WatchOptions } from 'vue'
+import type { NuxtApp } from 'nuxt/app'
 
-// Stub for #imports
-export const computed: any
-export const ref: any
-export const watch: any
-export const defineNuxtPlugin: any
-export const useAsyncGraphqlQuery: any
-export const useGraphqlState: any
-export const useNuxtApp: any
-export const useRuntimeConfig: any
-export const useRoute: any
+// Stub for #imports - Vue reactivity
+export function computed<T>(getter: () => T): ComputedRef<T>
+export function ref<T>(value: T): Ref<T>
+export function watch<T>(
+  source: WatchSource<T> | WatchSource<T>[],
+  callback: WatchCallback<T>,
+  options?: WatchOptions
+): () => void
+
+// Stub for #imports - Nuxt
+export function defineNuxtPlugin(plugin: (nuxtApp: NuxtApp) => void | Promise<void>): unknown
+export function useNuxtApp(): NuxtApp
+export function useRuntimeConfig(): Record<string, unknown>
+export function useRoute(): { path: string, params: Record<string, string>, query: Record<string, string> }
+
+// Stub for #imports - nuxt-graphql-middleware
+export function useAsyncGraphqlQuery<T = unknown>(
+  name: string,
+  params?: Record<string, unknown>,
+  options?: Record<string, unknown>
+): {
+  data: Ref<T | null>
+  pending: Ref<boolean>
+  refresh: () => Promise<void>
+  execute: () => Promise<void>
+  clear: () => void
+  error: Ref<Error | null>
+  status: Ref<string>
+}
+export function useGraphqlState(): Record<string, unknown>
 
 // Stub for #nuxt-graphql-middleware/operation-types
-export type Query = Record<string, any>
+export type Query = Record<string, unknown>
 
-// Stub for #build/graphql-operations
-export type PostFragment = any
-export type PageFragment = any
-export type MenuItemFragment = any
+// Stub for #build/graphql-operations - these are generated types
+export type PostFragment = Record<string, unknown>
+export type PageFragment = Record<string, unknown>
+export type MenuItemFragment = Record<string, unknown>

package/dist/runtime/util/content.js

@@ -0,0 +1,33 @@
+import { getRelativeImagePath } from "./images.js";
+export const findData = (data, nodes) => {
+  if (nodes.length === 0) return data;
+  return nodes.reduce((acc, node) => {
+    if (acc && typeof acc === "object" && node in acc) {
+      return acc[node];
+    }
+    return void 0;
+  }, data);
+};
+export const transformData = (data, nodes, fixImagePaths) => {
+  const transformedData = findData(data, nodes);
+  if (fixImagePaths && transformedData && typeof transformedData === "object" && "featuredImage" in transformedData) {
+    const featuredImage = transformedData.featuredImage;
+    if (featuredImage && typeof featuredImage === "object" && "node" in featuredImage) {
+      const node = featuredImage.node;
+      if (node && typeof node === "object" && "sourceUrl" in node && typeof node.sourceUrl === "string") {
+        node.relativePath = getRelativeImagePath(node.sourceUrl);
+      }
+    }
+  }
+  return transformedData;
+};
+export const normalizeUriParam = (params) => {
+  if (!params || typeof params !== "object") return params;
+  const paramsObj = params;
+  if ("uri" in paramsObj && typeof paramsObj.uri === "string") {
+    const uri = paramsObj.uri;
+    const normalizedUri = uri.endsWith("/") ? uri : `${uri}/`;
+    return { ...paramsObj, uri: normalizedUri };
+  }
+  return params;
+};

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpnuxt/core",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.9",
   "description": "Nuxt module for WordPress integration via GraphQL (WPGraphQL)",
   "keywords": [
     "nuxt",
@@ -43,8 +43,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@nuxt/kit": "4.2.2",
+    "@nuxt/kit": "4.3.0",
     "@radya/nuxt-dompurify": "^1.0.5",
+    "consola": "^3.4.0",
     "defu": "^6.1.4",
     "graphql": "^16.12.0",
     "nuxt-graphql-middleware": "5.3.2",
@@ -53,12 +54,12 @@
   "devDependencies": {
     "@nuxt/devtools": "^3.1.1",
     "@nuxt/module-builder": "^1.0.2",
-    "@nuxt/schema": "4.2.2",
+    "@nuxt/schema": "4.3.0",
     "@nuxt/test-utils": "^3.23.0",
-    "@types/node": "^25.0.9",
-    "nuxt": "4.2.2",
-    "vitest": "^4.0.17",
-    "vue-tsc": "^3.2.2"
+    "@types/node": "^25.2.1",
+    "nuxt": "4.3.0",
+    "vitest": "^4.0.18",
+    "vue-tsc": "^3.2.3"
   },
   "peerDependencies": {
     "nuxt": "^4.0.0"