@wpnuxt/core 2.0.0-alpha.1 → 2.0.0-alpha.3

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "wpnuxt",
   "configKey": "wpNuxt",
-  "version": "2.0.0-alpha.0",
+  "version": "2.0.0-alpha.2",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "3.6.1"

package/dist/module.mjs

@@ -1,10 +1,12 @@
 import { defu } from 'defu';
-import { promises, cpSync, existsSync, statSync, mkdirSync, writeFileSync } from 'node:fs';
+import { promises, cpSync, existsSync, statSync, readFileSync, writeFileSync } from 'node:fs';
+import { mkdir, writeFile } from 'node:fs/promises';
 import { join } 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';
 
 function randHashGenerator(length = 12) {
   return Math.random().toString(36).substring(2, 2 + length).toUpperCase().padEnd(length, "0");
@@ -63,16 +65,18 @@ const _parseDoc = async (doc) => {
     throw error;
   }
 };
-function processSelections(selections, level, query) {
+function processSelections(selections, level, query, canExtract = true) {
   if (!selections || selections.length === 0) return;
-  if (selections.length === 1 && selections[0]?.kind === "Field") {
-    query.nodes?.push(selections[0].name.value.trim());
+  const firstSelection = selections[0];
+  const hasSingleField = selections.length === 1 && firstSelection?.kind === "Field";
+  if (hasSingleField && canExtract && firstSelection.kind === "Field") {
+    query.nodes?.push(firstSelection.name.value.trim());
   }
   selections.forEach((s) => {
     if (s.kind === "FragmentSpread") {
       query.fragments?.push(s.name.value.trim());
     } else if (s.selectionSet?.selections) {
-      processSelections(s.selectionSet.selections, level + 1, query);
+      processSelections(s.selectionSet.selections, level + 1, query, canExtract && hasSingleField);
     }
   });
 }
@@ -109,13 +113,9 @@ async function prepareContext(ctx) {
     const fragmentSuffix = q.fragments?.length && q.nodes?.includes("nodes") ? "[]" : "";
     return q.fragments?.length ? q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ") : "any";
   };
-  const queryFnExp = (q, typed = false, lazy = false) => {
-    const baseName = fnName(q.name);
-    const functionName = lazy ? `useLazy${q.name}` : baseName;
+  const queryFnExp = (q, typed = false) => {
+    const functionName = fnName(q.name);
     if (!typed) {
-      if (lazy) {
-        return `export const ${functionName} = (params, options) => useWPContent('${q.name}', [${formatNodes(q.nodes)}], false, params, { ...options, lazy: true })`;
-      }
       return `export const ${functionName} = (params, options) => useWPContent('${q.name}', [${formatNodes(q.nodes)}], false, params, options)`;
     }
     return `  export const ${functionName}: (params?: ${q.name}QueryVariables, options?: WPContentOptions) => WPContentResult<${getFragmentType(q)}>`;
@@ -130,8 +130,7 @@ async function prepareContext(ctx) {
   ctx.generateImports = () => {
     const imports = [];
     queries.forEach((f) => {
-      imports.push(queryFnExp(f, false, false));
-      imports.push(queryFnExp(f, false, true));
+      imports.push(queryFnExp(f, false));
     });
     mutations.forEach((m) => {
       imports.push(mutationFnExp(m, false));
@@ -191,8 +190,7 @@ async function prepareContext(ctx) {
       "declare module '#wpnuxt' {"
     ];
     queries.forEach((f) => {
-      declarations.push(queryFnExp(f, true, false));
-      declarations.push(queryFnExp(f, true, true));
+      declarations.push(queryFnExp(f, true));
     });
     mutations.forEach((m) => {
       declarations.push(mutationFnExp(m, true));
@@ -201,18 +199,14 @@ async function prepareContext(ctx) {
     return declarations.join("\n");
   };
   ctx.fnImports = [
-    // Auto-import query composables (regular and lazy variants)
-    ...queries.flatMap((fn) => [
-      { from: "#wpnuxt", name: fnName(fn.name) },
-      { from: "#wpnuxt", name: `useLazy${fn.name}` }
-    ]),
+    // Auto-import query composables
+    ...queries.map((fn) => ({ from: "#wpnuxt", name: fnName(fn.name) })),
     // Auto-import mutation composables
     ...mutations.map((m) => ({ from: "#wpnuxt", name: mutationFnName(m.name) }))
   ];
   logger.debug("generated WPNuxt composables: ");
   queries.forEach((f) => {
     logger.debug(` ${fnName(f.name)}()`);
-    logger.debug(` useLazy${f.name}()`);
   });
   mutations.forEach((m) => {
     logger.debug(` ${mutationFnName(m.name)}()`);
@@ -234,6 +228,149 @@ async function prepareFunctions(ctx) {
   });
 }
 
+async function validateWordPressEndpoint(wordpressUrl, graphqlEndpoint = "/graphql", options = {}) {
+  const fullUrl = `${wordpressUrl}${graphqlEndpoint}`;
+  try {
+    const controller = new AbortController();
+    const timeout = setTimeout(() => controller.abort(), 1e4);
+    const response = await fetch(fullUrl, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        query: "{ __typename }"
+      }),
+      signal: controller.signal
+    });
+    clearTimeout(timeout);
+    if (!response.ok) {
+      throw new Error(
+        `[WPNuxt] WordPress GraphQL endpoint returned HTTP ${response.status}.
+
+URL: ${fullUrl}
+
+Possible causes:
+- The WordPress site is down or unreachable
+- WPGraphQL plugin is not installed or activated
+- The GraphQL endpoint path is incorrect (default: /graphql)
+
+Check your wpNuxt.wordpressUrl configuration in nuxt.config.ts`
+      );
+    }
+    const data = await response.json();
+    if (!data || typeof data !== "object") {
+      throw new Error(
+        `[WPNuxt] WordPress GraphQL endpoint returned invalid response.
+
+URL: ${fullUrl}
+
+The endpoint did not return valid JSON. Make sure WPGraphQL plugin is installed and activated.`
+      );
+    }
+    if (data.errors && !data.data) {
+      const errorMessage = data.errors[0]?.message || "Unknown error";
+      throw new Error(
+        `[WPNuxt] WordPress GraphQL endpoint returned an error: ${errorMessage}
+
+URL: ${fullUrl}
+
+Make sure WPGraphQL plugin is installed and activated on your WordPress site.`
+      );
+    }
+    if (options.schemaPath && !existsSync(options.schemaPath)) {
+      try {
+        execSync(`npx get-graphql-schema "${fullUrl}" > "${options.schemaPath}"`, {
+          stdio: "pipe",
+          timeout: 6e4
+          // 60 second timeout
+        });
+        patchWPGraphQLSchema(options.schemaPath);
+      } catch (err) {
+        const error = err;
+        throw new Error(
+          `[WPNuxt] Failed to download GraphQL schema.
+
+URL: ${fullUrl}
+Error: ${error.stderr?.toString() || error.message}
+
+Make sure WPGraphQL plugin is installed and activated on your WordPress site.`
+        );
+      }
+    }
+  } catch (error) {
+    if (error instanceof Error && error.message.startsWith("[WPNuxt]")) {
+      throw error;
+    }
+    const err = error;
+    const errorCode = err.code || err.cause?.code || "";
+    if (err.name === "AbortError") {
+      throw new Error(
+        `[WPNuxt] WordPress GraphQL endpoint timed out after 10 seconds.
+
+URL: ${fullUrl}
+
+The server did not respond in time. Check if the WordPress site is accessible.`
+      );
+    }
+    if (errorCode === "ENOTFOUND" || err.message?.includes("getaddrinfo")) {
+      throw new Error(
+        `[WPNuxt] WordPress site not found - DNS lookup failed.
+
+URL: ${fullUrl}
+
+The domain could not be resolved. Please check:
+- The URL is spelled correctly (no typos)
+- The domain exists and is properly configured
+- Your network connection is working
+
+Check your wpNuxt.wordpressUrl configuration in nuxt.config.ts`
+      );
+    }
+    if (errorCode === "ECONNREFUSED") {
+      throw new Error(
+        `[WPNuxt] Connection refused to WordPress site.
+
+URL: ${fullUrl}
+
+The server is not accepting connections. Check if the WordPress site is running.`
+      );
+    }
+    throw new Error(
+      `[WPNuxt] Failed to connect to WordPress GraphQL endpoint.
+
+URL: ${fullUrl}
+Error: ${err.message || "Unknown error"}
+
+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"),
+      ""
+    );
+  }
+  writeFileSync(schemaPath, schema);
+}
+
 const module$1 = defineNuxtModule({
   meta: {
     name: "wpnuxt",
@@ -265,8 +402,18 @@ const module$1 = defineNuxtModule({
     addPlugin(resolver.resolve("./runtime/plugins/graphqlConfig"));
     addPlugin(resolver.resolve("./runtime/plugins/graphqlErrors"));
     const mergedQueriesFolder = await mergeQueries(nuxt, wpNuxtConfig, resolver);
-    setupServerOptions(nuxt, resolver, logger);
-    setupClientOptions(nuxt, resolver, logger);
+    await setupServerOptions(nuxt, resolver, logger);
+    await setupClientOptions(nuxt, resolver, logger);
+    if (wpNuxtConfig.downloadSchema) {
+      const schemaPath = join(nuxt.options.rootDir, "schema.graphql");
+      logger.debug(`Validating WordPress endpoint: ${wpNuxtConfig.wordpressUrl}${wpNuxtConfig.graphqlEndpoint}`);
+      await validateWordPressEndpoint(
+        wpNuxtConfig.wordpressUrl,
+        wpNuxtConfig.graphqlEndpoint,
+        { schemaPath }
+      );
+      logger.debug("WordPress endpoint validation passed");
+    }
     await registerModules(nuxt, resolver, wpNuxtConfig, mergedQueriesFolder);
     nuxt.hook("devtools:customTabs", (tabs) => {
       const middlewareTab = tabs.find((tab) => tab.name === "nuxt-graphql-middleware");
@@ -289,7 +436,9 @@ const module$1 = defineNuxtModule({
     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: "useAsyncWPContent", as: "useAsyncWPContent", from: resolver.resolve("./runtime/composables/useWPContent") },
+      { name: "getRelativeImagePath", as: "getRelativeImagePath", from: resolver.resolve("./runtime/util/images") },
+      { name: "usePrevNextPost", as: "usePrevNextPost", from: resolver.resolve("./runtime/composables/usePrevNextPost") }
       // Note: useGraphqlMutation is auto-imported via nuxt-graphql-middleware with includeComposables: true
     ]);
     addComponentsDir({
@@ -333,9 +482,13 @@ function loadConfig(options, nuxt) {
   const config = defu({
     wordpressUrl: process.env.WPNUXT_WORDPRESS_URL,
     graphqlEndpoint: process.env.WPNUXT_GRAPHQL_ENDPOINT,
-    downloadSchema: process.env.WPNUXT_DOWNLOAD_SCHEMA ? process.env.WPNUXT_DOWNLOAD_SCHEMA === "true" : void 0,
+    // Only override downloadSchema if env var is explicitly set
+    downloadSchema: process.env.WPNUXT_DOWNLOAD_SCHEMA !== void 0 ? process.env.WPNUXT_DOWNLOAD_SCHEMA === "true" : void 0,
     debug: process.env.WPNUXT_DEBUG ? process.env.WPNUXT_DEBUG === "true" : void 0
   }, options);
+  if (config.downloadSchema === void 0) {
+    config.downloadSchema = true;
+  }
   nuxt.options.runtimeConfig.public.wordpressUrl = config.wordpressUrl;
   nuxt.options.runtimeConfig.public.wpNuxt = {
     wordpressUrl: config.wordpressUrl,
@@ -355,7 +508,8 @@ function loadConfig(options, nuxt) {
   return config;
 }
 const SERVER_OPTIONS_TEMPLATE = `import { defineGraphqlServerOptions } from '@wpnuxt/core/server-options'
-import { getHeader } from 'h3'
+import { getHeader, getCookie } from 'h3'
+import { useRuntimeConfig } from '#imports'
 
 /**
  * WPNuxt default server options for nuxt-graphql-middleware.
@@ -363,18 +517,32 @@ import { getHeader } from 'h3'
  * 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 if present
-        Authorization: getHeader(event, 'authorization') || ''
+        // Forward authorization header or token from cookie
+        Authorization: authorization
       }
     }
   },
@@ -385,7 +553,7 @@ export default defineGraphqlServerOptions({
   }
 })
 `;
-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)) {
@@ -393,9 +561,9 @@ function setupServerOptions(nuxt, _resolver, logger) {
     return;
   }
   if (!existsSync(serverDir)) {
-    mkdirSync(serverDir, { recursive: true });
+    await mkdir(serverDir, { recursive: true });
   }
-  writeFileSync(targetPath, SERVER_OPTIONS_TEMPLATE);
+  await writeFile(targetPath, SERVER_OPTIONS_TEMPLATE);
   logger.debug("Created graphqlMiddleware.serverOptions.ts with WPNuxt defaults (cookie/auth forwarding)");
 }
 const CLIENT_OPTIONS_TEMPLATE = `import { defineGraphqlClientOptions } from '@wpnuxt/core/client-options'
@@ -427,7 +595,7 @@ export default defineGraphqlClientOptions<{
   }
 })
 `;
-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)) {
@@ -435,9 +603,9 @@ function setupClientOptions(nuxt, _resolver, logger) {
     return;
   }
   if (!existsSync(appDir)) {
-    mkdirSync(appDir, { recursive: true });
+    await mkdir(appDir, { recursive: true });
   }
-  writeFileSync(targetPath, CLIENT_OPTIONS_TEMPLATE);
+  await writeFile(targetPath, CLIENT_OPTIONS_TEMPLATE);
   logger.debug("Created graphqlMiddleware.clientOptions.ts with WPNuxt defaults (preview mode support)");
 }
 function configureVercelSettings(nuxt, logger) {
@@ -471,7 +639,7 @@ async function registerModules(nuxt, resolver, wpNuxtConfig, mergedQueriesFolder
     graphqlEndpoint: `${wpNuxtConfig.wordpressUrl}${wpNuxtConfig.graphqlEndpoint}`,
     autoImportPatterns: [mergedQueriesFolder],
     includeComposables: true,
-    downloadSchema: wpNuxtConfig.downloadSchema,
+    downloadSchema: wpNuxtConfig.downloadSchema ?? true,
     enableFileUploads: true,
     // Use WPNuxt-branded API route prefix
     serverApiPrefix: "/api/wpnuxt",

package/dist/runtime/composables/usePrevNextPost.js

@@ -0,0 +1,22 @@
+import { useWPContent } from "./useWPContent.js";
+export async function usePrevNextPost(currentSlug) {
+  const { data, execute } = useWPContent("Posts", ["posts", "nodes"], false, { limit: 100 });
+  await execute();
+  const allPosts = data.value || [];
+  if (!allPosts.length) {
+    return { prev: null, next: null };
+  }
+  const cleanSlug = currentSlug.replace(/^\/|\/$/g, "");
+  const currentIndex = allPosts.findIndex(
+    (post) => post.slug === cleanSlug
+  );
+  if (currentIndex === -1) {
+    return { prev: null, next: null };
+  }
+  const prevPost = currentIndex < allPosts.length - 1 ? allPosts[currentIndex + 1] : null;
+  const nextPost = currentIndex > 0 ? allPosts[currentIndex - 1] : null;
+  return {
+    prev: prevPost ?? null,
+    next: nextPost ?? null
+  };
+}

package/dist/runtime/composables/useWPContent.js

@@ -1,10 +1,14 @@
 import { getRelativeImagePath } from "../util/images.js";
 import { computed, useAsyncGraphqlQuery } from "#imports";
 export const useWPContent = (queryName, nodes, fixImagePaths, params, options) => {
+  const mergedOptions = {
+    graphqlCaching: { client: true },
+    ...options
+  };
   const { data, pending, refresh, execute, clear, error, status } = useAsyncGraphqlQuery(
     queryName,
     params ?? {},
-    options
+    mergedOptions
   );
   const transformedData = computed(() => {
     const queryResult = data.value && typeof data.value === "object" && data.value !== null && "data" in data.value ? data.value.data : void 0;

package/dist/runtime/plugins/graphqlConfig.js

@@ -1,6 +1,5 @@
-import { defineNuxtPlugin } from "nuxt/app";
-import { useGraphqlState, useRuntimeConfig } from "#imports";
-export default defineNuxtPlugin((_NuxtApp) => {
+import { defineNuxtPlugin, useGraphqlState, useRuntimeConfig } from "#imports";
+export default defineNuxtPlugin(() => {
   const state = useGraphqlState();
   if (!state) {
     return;

package/dist/runtime/plugins/graphqlErrors.js

@@ -1,4 +1,4 @@
-import { defineNuxtPlugin, useNuxtApp } from "nuxt/app";
+import { defineNuxtPlugin, useNuxtApp } from "#imports";
 export default defineNuxtPlugin(() => {
   const nuxtApp = useNuxtApp();
   nuxtApp.hook("nuxt-graphql-middleware:errors", (errors) => {

package/dist/runtime/queries/Viewer.gql

@@ -1,12 +1,12 @@
 query Viewer {
   viewer {
-    username
-    userId
     id
-    email
-    description
+    userId
+    username
     firstName
     lastName
+    name
+    description
     locale
     url
     uri

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

@@ -7,5 +7,4 @@ fragment GeneralSettings on GeneralSettings {
   startOfWeek
   timezone
   timeFormat
-  email
 }

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

@@ -0,0 +1,24 @@
+/**
+ * Type stubs for Nuxt-generated imports.
+ * These are used during module development when .nuxt folder doesn't exist.
+ * Actual types are generated at runtime in consuming applications.
+ */
+
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Stub for #imports
+export const computed: 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 #nuxt-graphql-middleware/operation-types
+export type Query = Record<string, any>
+
+// Stub for #build/graphql-operations
+export type PostFragment = any
+export type PageFragment = any
+export type MenuItemFragment = any

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@wpnuxt/core",
-  "version": "2.0.0-alpha.1",
+  "version": "2.0.0-alpha.3",
   "description": "Nuxt module for WordPress integration via GraphQL (WPGraphQL)",
   "keywords": [
     "nuxt",
@@ -47,7 +47,7 @@
     "@radya/nuxt-dompurify": "^1.0.5",
     "defu": "^6.1.4",
     "graphql": "^16.12.0",
-    "nuxt-graphql-middleware": "5.3.0",
+    "nuxt-graphql-middleware": "5.3.1",
     "scule": "^1.3.0"
   },
   "devDependencies": {
@@ -65,7 +65,7 @@
   },
   "scripts": {
     "build": "nuxt-module-build build",
-    "dev:prepare": "nuxt-module-build build --stub && nuxt-module-build prepare",
+    "dev:prepare": "nuxt-module-build build --stub",
     "lint": "eslint src",
     "test": "vitest run",
     "test:watch": "vitest watch",