@wpnuxt/core 1.0.0-edge.4

package/README.md

@@ -0,0 +1,89 @@
+
+This module is still being developed and not ready for production usage yet.
+There will be many smaller alpha releases the coming weeks, often with breaking changes.
+
+I am working towards a stable release. And will inform about it here
+
+# WPNuxt
+
+[![npm version][npm-version-src]][npm-version-href]
+[![npm downloads][npm-downloads-src]][npm-downloads-href]
+[![License][license-src]][license-href]
+[![Nuxt][nuxt-src]][nuxt-href]
+
+Nuxt module for using WordPress as a headless CMS with a Nuxt 3 frontend
+
+- [✨  Release Notes](/CHANGELOG.md)
+<!-- - [🏀 Online playground](https://stackblitz.com/github/your-org/my-module?file=playground%2Fapp.vue) -->
+<!-- - [📖 &nbsp;Documentation](https://example.com) -->
+
+## Features
+
+- Content is fetched from WordPress using server-side GraphQL api calls
+- Support for (Gutenberg Blocks), using WPEngine's wp-graphql-content-blocks https://faustjs.org/tutorial/get-started-with-wp-graphql-content-blocks
+
+## Quick Setup
+
+1. Add `@vernaillen/wpnuxt` dependency to your project
+
+```bash
+# Using pnpm
+pnpm add -D @vernaillen/wpnuxt
+
+# Using yarn
+yarn add --dev @vernaillen/wpnuxt
+
+# Using npm
+npm install --save-dev @vernaillen/wpnuxt
+```
+
+2. Add '@vernaillen/wpnuxt' to the `modules` section of `nuxt.config.ts`
+
+```js
+export default defineNuxtConfig({
+  modules: [
+    '@vernaillen/wpnuxt'
+  ]
+})
+```
+
+That's it! You can now use the WPNuxt module in your Nuxt app ✨
+
+## Development
+
+```bash
+# Install dependencies
+npm install
+
+# Generate type stubs
+npm run dev:prepare
+
+# Develop with the playground
+npm run dev
+
+# Build the playground
+npm run dev:build
+
+# Run ESLint
+npm run lint
+
+# Run Vitest
+npm run test
+npm run test:watch
+
+# Release new version
+npm run release
+```
+
+<!-- Badges -->
+[npm-version-src]: https://img.shields.io/npm/v/@vernaillen/wpnuxt/latest.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-version-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+
+[npm-downloads-src]: https://img.shields.io/npm/dm/@vernaillen/wpnuxt.svg?style=flat&colorA=18181B&colorB=28CF8D
+[npm-downloads-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+
+[license-src]: https://img.shields.io/npm/l/@vernaillen/wpnuxt?style=flat&colorA=18181B&colorB=28CF8D
+[license-href]: https://www.npmjs.com/package/@vernaillen/wpnuxt
+
+[nuxt-src]: https://img.shields.io/badge/Nuxt-18181B?logo=nuxt.js
+[nuxt-href]: https://nuxt.com

package/dist/module.cjs

@@ -0,0 +1,5 @@
+module.exports = function(...args) {
+  return import('./module.mjs').then(m => m.default.call(this, ...args))
+}
+const _meta = module.exports.meta = require('./module.json')
+module.exports.getMeta = () => Promise.resolve(_meta)

package/dist/module.d.mts

@@ -0,0 +1,116 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface WPNuxtConfig {
+
+  /**
+   * Log level for the WPNuxt module
+   * @default 3
+   * @example 0 = silent, 1 = error, 2 = warn, 3 = info, 4 = debug, 5 = trace
+   */
+  logLevel?: number
+  /**
+   * URL of the WordPress site
+   *
+   * There is no default value for this option, so it's required.
+   *
+   * @example 'https://wordpress.wpnuxt.com'
+   */
+  wordpressUrl: string
+  frontendUrl: string
+
+  faustSecretKey?: string
+  defaultMenuName?: string
+
+  /**
+   * Enable custom components for Gutenberg blocks
+   * When disabled the module will use the renderedHtml of each block returned by WordPress
+   *
+   * @default true
+   */
+  blocks?: boolean
+
+  replaceSchema?: boolean
+  enableCache?: boolean
+
+  staging?: boolean
+  /**
+   * Generate composables based on the GraphQL queries, provided by both the WPNuxt module as the queries added by the user.
+   *
+   * @default { enabled: true, prefix: 'useWP' }
+   */
+  generateComposables?: WPNuxtConfigComposables
+
+  queries?: WPNuxtConfigQueries
+
+  /**
+   * Download the GraphQL schema and store it on disk.
+   *
+   * When setting this to false, the module will expect a graphql.schema file to be available.
+   * You could first enable this, commit the schema file and then set downloadSchema to false to avoid have to query the graphql introspection on each start of the application
+   *
+   * @default true
+   */
+  downloadSchema?: boolean
+}
+
+interface WPNuxtConfigComposables {
+  enabled?: boolean
+
+  /**
+   * Prefix to use for generated composables
+   *
+   * @example 'useWP' => 'useWPPages', 'useWPPosts', 'useWPMenu'
+   * @default 'useWP'
+   */
+  prefix?: string
+}
+
+interface WPNuxtConfigQueries {
+  /**
+   * @default true
+   */
+  usePredefinedQueries?: boolean
+
+  /**
+   * Folder for user defined queries
+   *
+   * relative to the src dir of your nuxt app
+   *
+   * @default extend/queries
+   */
+  extendDir?: string
+
+  /**
+   * The predefined queries & the user defined queries will be merged and placed in the queries output folder
+   *
+   * relative to the src dir of your nuxt app
+   *
+   * @default queries
+   */
+  outputDir?: string
+}
+
+declare const _default: _nuxt_schema.NuxtModule<WPNuxtConfig>;
+
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        wpNuxt: {
+            faustSecretKey: string;
+        };
+    }
+    interface PublicRuntimeConfig {
+        wpNuxt: WPNuxtConfig;
+    }
+    interface ConfigSchema {
+        wpNuxt: {
+            faustSecretKey: string;
+        };
+        runtimeConfig: {
+            public?: {
+                wpNuxt: WPNuxtConfig;
+            };
+        };
+    }
+}
+
+export { _default as default };

package/dist/module.d.ts

@@ -0,0 +1,116 @@
+import * as _nuxt_schema from '@nuxt/schema';
+
+interface WPNuxtConfig {
+
+  /**
+   * Log level for the WPNuxt module
+   * @default 3
+   * @example 0 = silent, 1 = error, 2 = warn, 3 = info, 4 = debug, 5 = trace
+   */
+  logLevel?: number
+  /**
+   * URL of the WordPress site
+   *
+   * There is no default value for this option, so it's required.
+   *
+   * @example 'https://wordpress.wpnuxt.com'
+   */
+  wordpressUrl: string
+  frontendUrl: string
+
+  faustSecretKey?: string
+  defaultMenuName?: string
+
+  /**
+   * Enable custom components for Gutenberg blocks
+   * When disabled the module will use the renderedHtml of each block returned by WordPress
+   *
+   * @default true
+   */
+  blocks?: boolean
+
+  replaceSchema?: boolean
+  enableCache?: boolean
+
+  staging?: boolean
+  /**
+   * Generate composables based on the GraphQL queries, provided by both the WPNuxt module as the queries added by the user.
+   *
+   * @default { enabled: true, prefix: 'useWP' }
+   */
+  generateComposables?: WPNuxtConfigComposables
+
+  queries?: WPNuxtConfigQueries
+
+  /**
+   * Download the GraphQL schema and store it on disk.
+   *
+   * When setting this to false, the module will expect a graphql.schema file to be available.
+   * You could first enable this, commit the schema file and then set downloadSchema to false to avoid have to query the graphql introspection on each start of the application
+   *
+   * @default true
+   */
+  downloadSchema?: boolean
+}
+
+interface WPNuxtConfigComposables {
+  enabled?: boolean
+
+  /**
+   * Prefix to use for generated composables
+   *
+   * @example 'useWP' => 'useWPPages', 'useWPPosts', 'useWPMenu'
+   * @default 'useWP'
+   */
+  prefix?: string
+}
+
+interface WPNuxtConfigQueries {
+  /**
+   * @default true
+   */
+  usePredefinedQueries?: boolean
+
+  /**
+   * Folder for user defined queries
+   *
+   * relative to the src dir of your nuxt app
+   *
+   * @default extend/queries
+   */
+  extendDir?: string
+
+  /**
+   * The predefined queries & the user defined queries will be merged and placed in the queries output folder
+   *
+   * relative to the src dir of your nuxt app
+   *
+   * @default queries
+   */
+  outputDir?: string
+}
+
+declare const _default: _nuxt_schema.NuxtModule<WPNuxtConfig>;
+
+declare module '@nuxt/schema' {
+    interface RuntimeConfig {
+        wpNuxt: {
+            faustSecretKey: string;
+        };
+    }
+    interface PublicRuntimeConfig {
+        wpNuxt: WPNuxtConfig;
+    }
+    interface ConfigSchema {
+        wpNuxt: {
+            faustSecretKey: string;
+        };
+        runtimeConfig: {
+            public?: {
+                wpNuxt: WPNuxtConfig;
+            };
+        };
+    }
+}
+
+export { _default as default };

package/dist/module.json

@@ -0,0 +1,10 @@
+{
+  "name": "@wpnuxt/core",
+  "version": "1.0.0-edge.4",
+  "configKey": "wpNuxt",
+  "nuxt": ">=3.1.0",
+  "builder": {
+    "@nuxt/module-builder": "0.8.1",
+    "unbuild": "2.0.0"
+  }
+}

package/dist/module.mjs

@@ -0,0 +1,357 @@
+import { promises, statSync, existsSync, cpSync } from 'node:fs';
+import { resolveFiles, defineNuxtModule, createResolver, addPlugin, addImports, addComponent, addServerHandler, installModule, hasNuxtModule, addTemplate } from '@nuxt/kit';
+import defu from 'defu';
+import { join } from 'pathe';
+import consola, { createConsola } from 'consola';
+import { ref } from 'vue';
+import { upperFirst } from 'scule';
+import { parse } from 'graphql';
+
+const name = "@wpnuxt/core";
+const version = "1.0.0-edge.4";
+
+const loggerRef = ref();
+const initLogger = (logLevel) => {
+  loggerRef.value = createConsola({
+    level: logLevel ? logLevel : 3,
+    formatOptions: {
+      colors: true,
+      compact: true,
+      date: true,
+      fancy: true
+    }
+  }).withTag("wpnuxt");
+  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);
+  }
+}
+
+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}`);
+    }
+    const query = {
+      name: operationDefinition.name.value.trim(),
+      nodes: [],
+      fragments: [],
+      params: {}
+    };
+    processSelections(operationDefinition.selectionSet.selections, 0, query);
+    return query;
+  });
+  return operations;
+};
+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());
+  }
+  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);
+    }
+  });
+}
+const parseDoc = _parseDoc;
+
+async function prepareContext(ctx) {
+  const logger = getLogger();
+  if (ctx.docs) {
+    await prepareFunctions(ctx);
+  }
+  const fnName = (fn) => ctx.composables.prefix + upperFirst(fn);
+  const fnExp = (q, typed = false) => {
+    const functionName = fnName(q.name);
+    if (!typed) {
+      const nodesArray = q.nodes?.map((n) => `'${n}'`);
+      return `export const ${functionName} = (params) => useWPContent('${q.name}', [${nodesArray?.join(",")}], false, params)`;
+    }
+    let fragmentSuffix = "";
+    if (q.fragments && q.fragments.length > 0 && q.nodes && q.nodes.length > 0 && q.nodes.includes("nodes")) {
+      fragmentSuffix = "[]";
+    }
+    const fragments = q.fragments && q.fragments.length > 0 ? q.fragments.map((f) => `${f}Fragment${fragmentSuffix}`).join(" | ") : "any";
+    return `  export const ${functionName}: (params?: ${q.name}QueryVariables) => AsyncData<${fragments}, FetchError | null | undefined>`;
+  };
+  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) }));
+  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;
+}
+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 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);
+}
+
+const defaultComposablesConfig = {
+  enabled: true,
+  prefix: "useWP"
+};
+const defaultConfigs = {
+  wordpressUrl: "",
+  frontendUrl: "",
+  faustSecretKey: "",
+  defaultMenuName: "main",
+  blocks: true,
+  replaceSchema: false,
+  enableCache: true,
+  staging: false,
+  logLevel: 3,
+  generateComposables: defaultComposablesConfig
+};
+const module = defineNuxtModule({
+  meta: {
+    name,
+    version,
+    configKey: "wpNuxt",
+    nuxt: ">=3.1.0"
+  },
+  // 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,
+      blocks: process.env.WPNUXT_BLOCKS ? process.env.WPNUXT_BLOCKS === "true" : options.blocks,
+      replaceSchema: process.env.WPNUXT_REPLACE_SCHEMA === "true" || options.replaceSchema,
+      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,
+      // TODO also allow below options as env vars?
+      logLevel: process.env.WPNUXT_LOG_LEVEL ? Number.parseInt(process.env.WPNUXT_LOG_LEVEL) : options.logLevel,
+      generateComposables: options.generateComposables
+    };
+    nuxt.options.runtimeConfig.wpNuxt = defu(nuxt.options.runtimeConfig.wpNuxt, {
+      faustSecretKey: process.env.WPNUXT_FAUST_SECRET_KEY ? process.env.WPNUXT_FAUST_SECRET_KEY : options.faustSecretKey
+    });
+    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");
+    if (publicWPNuxtConfig.blocks)
+      logger.info("Blocks 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")
+    });
+    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) {
+          let blocksQueriesPath;
+          if (m.entryPath.startsWith("../src/module")) {
+            blocksQueriesPath = join(nuxt.options.rootDir, "../src/runtime/queries/");
+          } else {
+            blocksQueriesPath = join("./node_modules", m.entryPath, "dist/runtime/queries/");
+          }
+          cpSync(blocksQueriesPath, queryOutputPath, { recursive: true });
+        }
+      }
+    } else {
+      logger.debug("!!! If you want to render Gutenberg blocks with separate vue components, please install the @wpnuxt/blocks module");
+    }
+    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,
+        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 }
+      `
+    });
+    nuxt.options.nitro.externals.inline.push(template.dst);
+    nuxt.options.alias["#graphql-middleware-server-options-build"] = template.dst;
+    if (publicWPNuxtConfig.generateComposables && publicWPNuxtConfig.generateComposables.enabled) {
+      logger.trace("Generating composables");
+      const composablesConfig = typeof publicWPNuxtConfig.generateComposables === "object" ? publicWPNuxtConfig.generateComposables : defaultComposablesConfig;
+      const ctx = await {
+        fns: [],
+        fnImports: [],
+        composables: composablesConfig
+      };
+      await generateWPNuxtComposables(ctx, queryOutputPath, srcResolver);
+      addTemplate({
+        write: true,
+        filename: "wpnuxt.mjs",
+        getContents: () => ctx.generateImports?.() || ""
+      });
+      addTemplate({
+        write: true,
+        filename: "wpnuxt/index.d.ts",
+        getContents: () => ctx.generateDeclarations?.() || ""
+      });
+      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 ::: ");
+  }
+});
+
+export { module as default };

package/dist/runtime/app/graphqlMiddleware.serverOptions.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("nuxt-graphql-middleware").GraphqlMiddlewareServerOptions<object>;
+export default _default;