@wpnuxt/core 1.0.0-edge.9 → 2.0.0-alpha.2

package/dist/module.mjs

@@ -1,70 +1,77 @@
-import { promises, statSync, existsSync, cpSync } from 'node:fs';
-import { resolveFiles, defineNuxtModule, createResolver, addPlugin, addImports, addComponent, addServerHandler, installModule, hasNuxtModule, addTemplate, addTypeTemplate } from '@nuxt/kit';
-import { join } from 'pathe';
-import consola, { createConsola } from 'consola';
-import { ref } from 'vue';
+import { defu } from 'defu';
+import { promises, cpSync, existsSync, statSync, readFileSync, writeFileSync, mkdirSync } from 'node:fs';
+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 { parse } from 'graphql';
-
-const name = "@wpnuxt/core";
-const version = "1.0.0-edge.9";
+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");
+}
 const loggerRef = ref();
-const initLogger = (logLevel) => {
-  loggerRef.value = createConsola({
-    level: logLevel ? logLevel : 3,
-    formatOptions: {
-      colors: true,
-      compact: true,
-      date: true,
-      fancy: true
-    }
-  }).withTag("wpnuxt");
+const initLogger = (debug) => {
+  loggerRef.value = useLogger("wpnuxt", { level: debug ? 4 : 3 });
   return loggerRef.value;
 };
-const getLogger = () => {
-  if (loggerRef.value) {
-    return loggerRef.value;
-  }
-};
-function validateConfig(options) {
-  if (!options.wordpressUrl || options.wordpressUrl.length === 0) {
-    throw new Error("WPNuxt error: WordPress url is missing");
-  } else if (options.wordpressUrl.substring(options.wordpressUrl.length - 1) === "/") {
-    throw new Error("WPNuxt error: WordPress url should not have a trailing slash: " + options.wordpressUrl);
-  }
-  if (options.frontendUrl && options.frontendUrl.substring(options.frontendUrl.length - 1) === "/") {
-    throw new Error("WPNuxt error: frontend url should not have a trailing slash: " + options.frontendUrl);
+function getLogger() {
+  return loggerRef.value;
+}
+async function mergeQueries(nuxt, wpNuxtConfig, resolver) {
+  const logger = getLogger();
+  const baseDir = nuxt.options.srcDir || nuxt.options.rootDir;
+  const { resolve } = createResolver(baseDir);
+  const queryOutputPath = resolve(wpNuxtConfig.queries.mergedOutputFolder);
+  const userQueryPath = resolve(wpNuxtConfig.queries.extendFolder);
+  const defaultQueriesPath = resolver.resolve("./runtime/queries");
+  await promises.rm(queryOutputPath, { recursive: true, force: true });
+  cpSync(defaultQueriesPath, queryOutputPath, { recursive: true });
+  if (existsSync(userQueryPath)) {
+    logger.debug("Extending queries:", userQueryPath);
+    cpSync(userQueryPath, queryOutputPath, { recursive: true });
   }
+  logger.debug("Merged queries folder:", queryOutputPath);
+  return queryOutputPath;
 }
 
 const _parseDoc = async (doc) => {
-  const { definitions } = parse(doc);
-  const operations = definitions.filter(({ kind }) => kind === "OperationDefinition").map((definition) => {
-    const operationDefinition = definition;
-    if (!operationDefinition.name?.value) {
-      throw new Error(`Operation name missing in: ${doc}`);
+  if (!doc || typeof doc !== "string" || doc.trim().length === 0) {
+    throw new Error("WPNuxt: Invalid GraphQL document - document is empty or not a string");
+  }
+  try {
+    const { definitions } = parse(doc);
+    const operations = definitions.filter(({ kind }) => kind === "OperationDefinition").map((definition) => {
+      const operationDefinition = definition;
+      if (!operationDefinition.name?.value) {
+        throw new Error("WPNuxt: GraphQL operation is missing a name. All queries and mutations must have a name.");
+      }
+      const query = {
+        name: operationDefinition.name.value.trim(),
+        nodes: [],
+        fragments: [],
+        params: {},
+        operation: operationDefinition.operation
+      };
+      processSelections(operationDefinition.selectionSet.selections, 0, query);
+      return query;
+    });
+    return operations;
+  } catch (error) {
+    if (error instanceof GraphQLError) {
+      throw new TypeError(`WPNuxt: Failed to parse GraphQL document - ${error.message}`);
     }
-    const query = {
-      name: operationDefinition.name.value.trim(),
-      nodes: [],
-      fragments: [],
-      params: {}
-    };
-    processSelections(operationDefinition.selectionSet.selections, 0, query);
-    return query;
-  });
-  return operations;
+    throw error;
+  }
 };
 function processSelections(selections, level, query) {
-  if (!selections || selections.length === 0)
-    return;
-  if (selections.length === 1 && selections[0].kind === "Field") {
-    query.nodes.push(selections[0].name.value.trim());
+  if (!selections || selections.length === 0) return;
+  if (selections.length === 1 && selections[0]?.kind === "Field") {
+    query.nodes?.push(selections[0].name.value.trim());
   }
   selections.forEach((s) => {
     if (s.kind === "FragmentSpread") {
-      query.fragments.push(s.name.value.trim());
+      query.fragments?.push(s.name.value.trim());
     } else if (s.selectionSet?.selections) {
       processSelections(s.selectionSet.selections, level + 1, query);
     }
@@ -72,248 +79,393 @@ function processSelections(selections, level, query) {
 }
 const parseDoc = _parseDoc;
 
+const SCHEMA_PATTERN = /schema\.(?:gql|graphql)$/i;
+const allowDocument = (f, resolver) => {
+  if (SCHEMA_PATTERN.test(f)) return false;
+  try {
+    return statSync(resolver.resolve(f)).size > 0;
+  } catch {
+    return false;
+  }
+};
+async function generateWPNuxtComposables(ctx, queryOutputPath, resolver) {
+  const gqlMatch = "**/*.{gql,graphql}";
+  const documents = [];
+  const files = (await resolveFiles(queryOutputPath, [gqlMatch, "!**/schemas"], { followSymbolicLinks: false })).filter((doc) => allowDocument(doc, resolver));
+  documents.push(...files);
+  ctx.docs = documents;
+  await prepareContext(ctx);
+}
 async function prepareContext(ctx) {
   const logger = getLogger();
   if (ctx.docs) {
     await prepareFunctions(ctx);
   }
+  const queries = ctx.fns.filter((f) => f.operation === "query");
+  const mutations = ctx.fns.filter((f) => f.operation === "mutation");
   const fnName = (fn) => ctx.composablesPrefix + upperFirst(fn);
-  const fnExp = (q, typed = false) => {
-    const functionName = fnName(q.name);
+  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";
+  };
+  const queryFnExp = (q, typed = false, lazy = false) => {
+    const baseName = fnName(q.name);
+    const functionName = lazy ? `useLazy${q.name}` : baseName;
     if (!typed) {
-      return `export const ${functionName} = (params) => useWPContent('${q.name}', [${q.nodes?.map((n) => `'${n}'`).join(",")}], false, params)`;
+      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)`;
     }
-    const fragmentSuffix = q.fragments?.length && q.nodes?.includes("nodes") ? "[]" : "";
-    const fragments = q.fragments?.length ? q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ") : "any";
-    return `  export const ${functionName}: (params?: ${q.name}QueryVariables) => AsyncData<${fragments}, FetchError | null | undefined>`;
+    return `  export const ${functionName}: (params?: ${q.name}QueryVariables, options?: WPContentOptions) => WPContentResult<${getFragmentType(q)}>`;
+  };
+  const mutationFnExp = (m, typed = false) => {
+    const functionName = mutationFnName(m.name);
+    if (!typed) {
+      return `export const ${functionName} = (variables, options) => useGraphqlMutation('${m.name}', variables, options)`;
+    }
+    return `  export const ${functionName}: (variables: ${m.name}MutationVariables, options?: WPMutationOptions) => Promise<WPMutationResult<${m.name}Mutation>>`;
+  };
+  ctx.generateImports = () => {
+    const imports = [];
+    queries.forEach((f) => {
+      imports.push(queryFnExp(f, false, false));
+      imports.push(queryFnExp(f, false, true));
+    });
+    mutations.forEach((m) => {
+      imports.push(mutationFnExp(m, false));
+    });
+    return imports.join("\n");
+  };
+  const typeSet = /* @__PURE__ */ new Set();
+  queries.forEach((o) => {
+    typeSet.add(`${o.name}QueryVariables`);
+    o.fragments?.forEach((f) => typeSet.add(`${f}Fragment`));
+  });
+  mutations.forEach((m) => {
+    typeSet.add(`${m.name}MutationVariables`);
+    typeSet.add(`${m.name}Mutation`);
+  });
+  ctx.generateDeclarations = () => {
+    const declarations = [
+      `import type { ${[...typeSet].join(", ")} } from '#build/graphql-operations'`,
+      "import type { ComputedRef, Ref } from 'vue'",
+      "import type { AsyncDataRequestStatus } from '#app'",
+      "import type { GraphqlResponse } from 'nuxt-graphql-middleware/types'",
+      "",
+      "export interface WPContentOptions {",
+      "  /** Whether to resolve the async function after loading the route, instead of blocking client-side navigation. Default: false */",
+      "  lazy?: boolean",
+      "  /** Whether to fetch data on the server (during SSR). Default: true */",
+      "  server?: boolean",
+      "  /** Whether to fetch immediately. Default: true */",
+      "  immediate?: boolean",
+      "  /** Watch reactive sources to auto-refresh */",
+      "  watch?: unknown[]",
+      "  /** Transform function to alter the result */",
+      "  transform?: (input: unknown) => unknown",
+      "  /** Additional options to pass to useAsyncGraphqlQuery */",
+      "  [key: string]: unknown",
+      "}",
+      "",
+      "export interface WPMutationOptions {",
+      "  /** Fetch options to pass to the request */",
+      "  fetchOptions?: RequestInit",
+      "  /** Additional options */",
+      "  [key: string]: unknown",
+      "}",
+      "",
+      "interface WPContentResult<T> {",
+      "  data: ComputedRef<T | undefined>",
+      "  pending: Ref<boolean>",
+      "  refresh: () => Promise<void>",
+      "  execute: () => Promise<void>",
+      "  clear: () => void",
+      "  error: Ref<Error | undefined>",
+      "  status: Ref<AsyncDataRequestStatus>",
+      "}",
+      "",
+      "type WPMutationResult<T> = GraphqlResponse<T>",
+      "",
+      "declare module '#wpnuxt' {"
+    ];
+    queries.forEach((f) => {
+      declarations.push(queryFnExp(f, true, false));
+      declarations.push(queryFnExp(f, true, true));
+    });
+    mutations.forEach((m) => {
+      declarations.push(mutationFnExp(m, true));
+    });
+    declarations.push("}");
+    return declarations.join("\n");
   };
-  ctx.generateImports = () => [
-    ...ctx.fns.map((f) => fnExp(f))
-  ].join("\n");
-  const types = [];
-  ctx.fns.forEach((o) => types.push(...getQueryTypeTemplate(o)));
-  ctx.generateDeclarations = () => [
-    `import type { ${[...new Set(types)].join(", ")} } from '#build/graphql-operations'`,
-    "import { AsyncData } from 'nuxt/app'",
-    "import { FetchError } from 'ofetch'",
-    "declare module '#wpnuxt' {",
-    ...[
-      ...ctx.fns.map((f) => fnExp(f, true))
-    ],
-    "}"
-  ].join("\n");
-  ctx.fnImports = ctx.fns.map((fn) => ({ from: "#wpnuxt", name: fnName(fn.name) }));
+  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 mutation composables
+    ...mutations.map((m) => ({ from: "#wpnuxt", name: mutationFnName(m.name) }))
+  ];
   logger.debug("generated WPNuxt composables: ");
-  ctx.fns.forEach((f) => logger.debug(` ${fnName(f.name)}()`));
-}
-function getQueryTypeTemplate(q) {
-  const types = [];
-  types.push(`${q.name}QueryVariables`);
-  if (q.fragments && q.fragments.length > 0) {
-    q.fragments.forEach((f) => types.push(`${f}Fragment`));
-  }
-  return types;
+  queries.forEach((f) => {
+    logger.debug(` ${fnName(f.name)}()`);
+    logger.debug(` useLazy${f.name}()`);
+  });
+  mutations.forEach((m) => {
+    logger.debug(` ${mutationFnName(m.name)}()`);
+  });
 }
 async function prepareFunctions(ctx) {
   if (!ctx.docs) {
     getLogger().error("no GraphQL query documents were found!");
     return;
   }
-  for await (const doc of ctx.docs) {
-    const operations = await parseDoc(await promises.readFile(doc, "utf8"));
-    operations.forEach((query) => {
-      ctx.fns.push(query);
+  const operations = await Promise.all(
+    ctx.docs.map(async (doc) => {
+      const content = await promises.readFile(doc, "utf8");
+      return parseDoc(content);
+    })
+  );
+  operations.flat().forEach((query) => {
+    ctx.fns.push(query);
+  });
+}
+
+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`
+    );
   }
 }
-
-const allowDocument = (f, resolver) => {
-  const isSchema = f.match(/([^/]+)\.(gql|graphql)$/)?.[0]?.toLowerCase().includes("schema");
-  return !isSchema && !!statSync(resolver.resolve(f)).size;
-};
-async function generateWPNuxtComposables(ctx, queryOutputPath, resolver) {
-  const gqlMatch = "**/*.{gql,graphql}";
-  const documents = [];
-  const files = (await resolveFiles(queryOutputPath, [gqlMatch, "!**/schemas"], { followSymbolicLinks: false })).filter((doc) => allowDocument(doc, resolver));
-  documents.push(...files);
-  ctx.docs = documents;
-  await prepareContext(ctx);
+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 defaultConfigs = {
-  wordpressUrl: "",
-  frontendUrl: "",
-  defaultMenuName: "main",
-  enableCache: true,
-  staging: false,
-  logLevel: 3,
-  composablesPrefix: "useWP"
-};
-const module = defineNuxtModule({
+const module$1 = defineNuxtModule({
   meta: {
-    name,
-    version,
-    configKey: "wpNuxt",
-    nuxt: ">=3.1.0"
+    name: "wpnuxt",
+    configKey: "wpNuxt"
+  },
+  defaults: {
+    wordpressUrl: void 0,
+    graphqlEndpoint: "/graphql",
+    queries: {
+      extendFolder: "extend/queries/",
+      mergedOutputFolder: ".queries/"
+    },
+    downloadSchema: true,
+    debug: false,
+    cache: {
+      enabled: true,
+      maxAge: 60 * 5,
+      // 5 minutes
+      swr: true
+    }
   },
-  // Default configuration options of the Nuxt module
-  defaults: defaultConfigs,
   async setup(options, nuxt) {
     const startTime = (/* @__PURE__ */ new Date()).getTime();
-    consola.log("::: Starting WPNuxt setup ::: ");
-    const publicWPNuxtConfig = {
-      wordpressUrl: process.env.WPNUXT_WORDPRESS_URL || options.wordpressUrl,
-      frontendUrl: process.env.WPNUXT_FRONTEND_URL || options.frontendUrl,
-      defaultMenuName: process.env.WPNUXT_DEFAULT_MENU_NAME || options.defaultMenuName,
-      enableCache: process.env.WPNUXT_ENABLE_CACHE ? process.env.WPNUXT_ENABLE_CACHE === "true" : options.enableCache,
-      staging: process.env.WPNUXT_STAGING === "true" || options.staging,
-      downloadSchema: process.env.WPNUXT_DOWNLOAD_SCHEMA === "true" || options.downloadSchema,
-      logLevel: process.env.WPNUXT_LOG_LEVEL ? Number.parseInt(process.env.WPNUXT_LOG_LEVEL) : options.logLevel,
-      composablesPrefix: process.env.WPNUXT_COMPOSABLES_PREFIX || options.composablesPrefix
-    };
-    nuxt.options.runtimeConfig.public.wpNuxt = publicWPNuxtConfig;
-    validateConfig(publicWPNuxtConfig);
-    const logger = initLogger(publicWPNuxtConfig.logLevel);
-    logger.info("Connecting GraphQL to", publicWPNuxtConfig.wordpressUrl);
-    logger.info("frontendUrl:", publicWPNuxtConfig.frontendUrl);
-    if (publicWPNuxtConfig.enableCache)
-      logger.info("Cache enabled");
-    logger.debug("Debug mode enabled, log level:", publicWPNuxtConfig.logLevel);
-    if (publicWPNuxtConfig.staging)
-      logger.info("Staging enabled");
-    const { resolve } = createResolver(import.meta.url);
-    const resolveRuntimeModule = (path) => resolve("./runtime", path);
-    const srcResolver = createResolver(nuxt.options.srcDir);
-    nuxt.options.alias["#wpnuxt"] = resolve(nuxt.options.buildDir, "wpnuxt");
-    nuxt.options.alias["#wpnuxt/*"] = resolve(nuxt.options.buildDir, "wpnuxt", "*");
-    nuxt.options.alias["#wpnuxt/types"] = resolve("./types");
-    nuxt.options.nitro.alias = nuxt.options.nitro.alias || {};
-    nuxt.options.nitro.alias["#wpnuxt/types"] = resolve("./types");
-    nuxt.options.nitro.externals = nuxt.options.nitro.externals || {};
-    nuxt.options.nitro.externals.inline = nuxt.options.nitro.externals.inline || [];
-    addPlugin({
-      src: resolveRuntimeModule("plugins/vue-sanitize-directive")
-    });
-    addImports([
-      { name: "isStaging", as: "isStaging", from: resolveRuntimeModule("./composables/isStaging") },
-      { name: "useWPContent", as: "useWPContent", from: resolveRuntimeModule("./composables/useWPContent") },
-      { name: "parseDoc", as: "parseDoc", from: resolveRuntimeModule("./composables/useParser") },
-      { name: "usePrevNextPost", as: "usePrevNextPost", from: resolveRuntimeModule("./composables/usePrevNextPost") },
-      { name: "loginUser", as: "loginUser", from: resolveRuntimeModule("./composables/user") },
-      { name: "logoutUser", as: "logoutUser", from: resolveRuntimeModule("./composables/user") },
-      { name: "getCurrentUserId", as: "getCurrentUserId", from: resolveRuntimeModule("./composables/user") },
-      { name: "getCurrentUserName", as: "getCurrentUserName", from: resolveRuntimeModule("./composables/user") },
-      { name: "useTokens", as: "useTokens", from: resolveRuntimeModule("./composables/useTokens") },
-      { name: "useWPUri", as: "useWPUri", from: resolveRuntimeModule("./composables/useWPUri") },
-      { name: "useFeaturedImage", as: "useFeaturedImage", from: resolveRuntimeModule("./composables/useFeaturedImage") }
-    ]);
-    addComponent({ name: "StagingBanner", filePath: resolveRuntimeModule("./components/StagingBanner") });
-    addComponent({ name: "WPNuxtLogo", filePath: resolveRuntimeModule("./components/WPNuxtLogo") });
-    addComponent({ name: "WordPressLogo", filePath: resolveRuntimeModule("./components/WordPressLogo") });
-    addServerHandler({
-      route: "/api/wpContent",
-      handler: resolveRuntimeModule("./server/api/wpContent.post")
-    });
-    addServerHandler({
-      route: "/api/purgeCache",
-      handler: resolveRuntimeModule("./server/api/purgeCache.get")
+    const wpNuxtConfig = loadConfig(options, nuxt);
+    const logger = initLogger(wpNuxtConfig.debug);
+    logger.debug("Starting WPNuxt in debug mode");
+    const resolver = createResolver(import.meta.url);
+    nuxt.options.runtimeConfig.public.buildHash = randHashGenerator();
+    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);
+    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");
+      if (middlewareTab) {
+        middlewareTab.title = "WPNuxt GraphQL";
+        middlewareTab.icon = "simple-icons:wordpress";
+      }
     });
-    await installModule("@vueuse/nuxt", {});
-    const queryOutputPath = resolve((nuxt.options.srcDir || nuxt.options.rootDir) + "/.queries/");
-    await promises.rm(queryOutputPath, { recursive: true, force: true });
-    const userQueryPath = "~/extend/queries/".replace(/^(~~|@@)/, nuxt.options.rootDir).replace(/^(~|@)/, nuxt.options.srcDir);
-    const userQueryPathExists = existsSync(userQueryPath);
-    cpSync(resolveRuntimeModule("./queries/"), queryOutputPath, { recursive: true });
-    if (hasNuxtModule("@wpnuxt/blocks")) {
-      for (const m of nuxt.options._installedModules) {
-        if (m.meta.name === "@wpnuxt/blocks" && m.entryPath) {
-          logger.debug("Loading queries from @wpnuxt/blocks");
-          let blocksQueriesPath;
-          if (m.entryPath.startsWith("../")) {
-            blocksQueriesPath = join(nuxt.options.rootDir, "../", m.entryPath, "./runtime/queries/");
-          } else {
-            blocksQueriesPath = join("./node_modules", m.entryPath, "dist/runtime/queries/");
-          }
-          cpSync(blocksQueriesPath, queryOutputPath, { recursive: true });
+    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/**"] = {
+        cache: {
+          maxAge,
+          swr: wpNuxtConfig.cache?.swr !== false
         }
-      }
-    } else {
-      logger.debug("Tip: Install the @wpnuxt/blocks module if you want to render Gutenberg blocks with separate vue components");
-      addTemplate({
-        write: true,
-        filename: "wpnuxt/blocks.mjs",
-        getContents: () => `export { }`
-      });
-      nuxt.options.alias["#wpnuxt/blocks"] = resolve(nuxt.options.buildDir, "wpnuxt/blocks");
+      };
+      logger.debug(`Server-side caching enabled for GraphQL requests (maxAge: ${maxAge}s, SWR: ${wpNuxtConfig.cache?.swr !== false})`);
     }
-    if (userQueryPathExists) {
-      logger.debug("Extending queries:", userQueryPath);
-      cpSync(resolve(userQueryPath), queryOutputPath, { recursive: true });
-    }
-    logger.debug("Copied merged queries in folder:", queryOutputPath);
-    await installModule("nuxt-graphql-middleware", {
-      debug: publicWPNuxtConfig.logLevel ? publicWPNuxtConfig.logLevel > 3 : false,
-      graphqlEndpoint: `${publicWPNuxtConfig.wordpressUrl}/graphql`,
-      downloadSchema: publicWPNuxtConfig.downloadSchema,
-      codegenConfig: {
-        silent: false,
-        skipTypename: true,
-        useTypeImports: true,
-        // inlineFragmentTypes: 'combine',
-        dedupeFragments: true,
-        onlyOperationTypes: true,
-        avoidOptionals: false,
-        maybeValue: "T | undefined",
-        disableOnBuild: false,
-        gqlImport: "graphql-request#wpnuxt",
-        namingConvention: {
-          enumValues: "change-case-all#upperCaseFirst"
-        },
-        documents: [
-          resolve("!./graphql/**/*")
-        ]
-      },
-      codegenSchemaConfig: {
-        urlSchemaOptions: {
-          headers: {
-            Authorization: "server-token"
-          }
-        }
-      },
-      outputDocuments: true,
-      autoImportPatterns: queryOutputPath,
-      includeComposables: true,
-      devtools: true
-    });
-    const resolvedPath = resolveRuntimeModule("./app/graphqlMiddleware.serverOptions");
-    const template = addTemplate({
-      filename: "graphqlMiddleware.serverOptions.ts",
-      write: true,
-      getContents: () => `
-      import type { GraphqlMiddlewareServerOptions } from '#graphql-middleware/types'
-      import serverOptions from '${resolvedPath}'
-      import type { GraphqlServerResponse } from '#graphql-middleware/types'
-      import type { GraphqlMiddlewareResponseUnion } from '#build/nuxt-graphql-middleware'
-
-      type GraphqlResponseAdditions =
-        typeof serverOptions extends GraphqlMiddlewareServerOptions<infer R> ? R : {}
-
-      export type GraphqlResponse<T> = GraphqlServerResponse<T> & GraphqlResponseAdditions
-
-      export type GraphqlResponseTyped = GraphqlResponse<GraphqlMiddlewareResponseUnion>
-
-      export { serverOptions }
-      `
+    configureVercelSettings(nuxt, logger);
+    addImports([
+      { name: "useWPContent", as: "useWPContent", from: resolver.resolve("./runtime/composables/useWPContent") },
+      { name: "useAsyncWPContent", as: "useAsyncWPContent", from: resolver.resolve("./runtime/composables/useWPContent") }
+      // Note: useGraphqlMutation is auto-imported via nuxt-graphql-middleware with includeComposables: true
+    ]);
+    addComponentsDir({
+      path: resolver.resolve("./runtime/components"),
+      pathPrefix: false,
+      prefix: "",
+      global: true
     });
-    nuxt.options.nitro.externals.inline.push(template.dst);
-    nuxt.options.alias["#graphql-middleware-server-options-build"] = template.dst;
     logger.trace("Start generating composables");
-    const ctx = await {
+    const ctx = {
       fns: [],
       fnImports: [],
-      composablesPrefix: publicWPNuxtConfig.composablesPrefix
+      composablesPrefix: "use"
     };
-    await generateWPNuxtComposables(ctx, queryOutputPath, srcResolver);
+    await generateWPNuxtComposables(ctx, mergedQueriesFolder, createResolver(nuxt.options.srcDir));
+    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 || [];
     addTemplate({
       write: true,
       filename: "wpnuxt/index.mjs",
@@ -327,16 +479,194 @@ const module = defineNuxtModule({
     nuxt.hook("imports:extend", (autoimports) => {
       autoimports.push(...ctx.fnImports || []);
     });
-    nuxt.hook("nitro:init", async (nitro) => {
-      const keys = await nitro.storage.getKeys("cache:content");
-      keys.forEach(async (key) => {
-        if (key.startsWith("cache:content"))
-          await nitro.storage.removeItem(key);
-      });
-    });
-    const endTime = (/* @__PURE__ */ new Date()).getTime();
-    logger.success("::: Finished WPNuxt setup in " + (endTime - startTime) + "ms ::: ");
+    logger.trace("Finished generating composables");
+    logger.info(`WPNuxt module loaded in ${(/* @__PURE__ */ new Date()).getTime() - startTime}ms`);
   }
 });
+function loadConfig(options, nuxt) {
+  const config = defu({
+    wordpressUrl: process.env.WPNUXT_WORDPRESS_URL,
+    graphqlEndpoint: process.env.WPNUXT_GRAPHQL_ENDPOINT,
+    // 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,
+    graphqlEndpoint: config.graphqlEndpoint,
+    cache: {
+      enabled: config.cache?.enabled ?? true,
+      maxAge: config.cache?.maxAge ?? 300,
+      swr: config.cache?.swr ?? true
+    }
+  };
+  if (!config.wordpressUrl?.trim()) {
+    throw new Error("WPNuxt error: WordPress url is missing");
+  }
+  if (config.wordpressUrl.endsWith("/")) {
+    throw new Error(`WPNuxt error: WordPress url should not have a trailing slash: ${config.wordpressUrl}`);
+  }
+  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)
+  }
+})
+`;
+function setupServerOptions(nuxt, _resolver, logger) {
+  const serverDir = nuxt.options.serverDir;
+  const targetPath = join(serverDir, "graphqlMiddleware.serverOptions.ts");
+  if (existsSync(targetPath)) {
+    logger.debug("Using existing graphqlMiddleware.serverOptions.ts from project");
+    return;
+  }
+  if (!existsSync(serverDir)) {
+    mkdirSync(serverDir, { recursive: true });
+  }
+  writeFileSync(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'
+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
+    }
+  }
+})
+`;
+function setupClientOptions(nuxt, _resolver, logger) {
+  const appDir = nuxt.options.dir.app;
+  const targetPath = join(appDir, "graphqlMiddleware.clientOptions.ts");
+  if (existsSync(targetPath)) {
+    logger.debug("Using existing graphqlMiddleware.clientOptions.ts from project");
+    return;
+  }
+  if (!existsSync(appDir)) {
+    mkdirSync(appDir, { recursive: true });
+  }
+  writeFileSync(targetPath, CLIENT_OPTIONS_TEMPLATE);
+  logger.debug("Created graphqlMiddleware.clientOptions.ts with WPNuxt defaults (preview mode support)");
+}
+function configureVercelSettings(nuxt, logger) {
+  const isVercel = process.env.VERCEL === "1" || nuxt.options.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;
+      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 };
+      logger.debug("Enabled SSR for all routes (routeRules['/**'] = { ssr: true })");
+    }
+  }
+}
+async function registerModules(nuxt, resolver, wpNuxtConfig, mergedQueriesFolder) {
+  const logger = getLogger();
+  async function registerModule(name, key, options) {
+    if (!hasNuxtModule(name)) {
+      await installModule(name, options);
+    } else {
+      logger.debug(`${name} module already registered, using the 'graphqlMiddleware' config from nuxt.config.ts`);
+      nuxt.options[key] = defu(nuxt.options[key], options);
+    }
+  }
+  await registerModule("nuxt-graphql-middleware", "graphql", {
+    debug: wpNuxtConfig.debug,
+    graphqlEndpoint: `${wpNuxtConfig.wordpressUrl}${wpNuxtConfig.graphqlEndpoint}`,
+    autoImportPatterns: [mergedQueriesFolder],
+    includeComposables: true,
+    downloadSchema: wpNuxtConfig.downloadSchema ?? true,
+    enableFileUploads: true,
+    // Use WPNuxt-branded API route prefix
+    serverApiPrefix: "/api/wpnuxt",
+    clientCache: {
+      // Enable or disable the caching feature.
+      enabled: true,
+      // Cache a maximum of 50 queries (default: 100).
+      maxSize: 50
+    },
+    codegenConfig: {
+      // WordPress-specific scalar mappings
+      scalars: {
+        DateTime: "string",
+        ID: "string"
+      }
+    },
+    experimental: {
+      // Use improved query parameter encoding for better URL handling
+      improvedQueryParamEncoding: true
+    }
+  });
+  await registerModule("@radya/nuxt-dompurify", "dompurify", {});
+}
 
-export { module as default };
+export { module$1 as default };