nuxt-graphql-middleware 2.0.0 → 2.1.0

package/dist/module.mjs

@@ -0,0 +1,325 @@
+import path from 'path';
+import fs from 'fs';
+import mkdirp from 'mkdirp';
+import chokidar from 'chokidar';
+import consola from 'consola';
+import express from 'express';
+import { GraphQLClient } from 'graphql-request';
+import { generate } from '@graphql-codegen/cli';
+import * as PluginTypescript from '@graphql-codegen/typescript';
+import * as PluginTypescriptOperations from '@graphql-codegen/typescript-operations';
+import * as PluginSchemaAst from '@graphql-codegen/schema-ast';
+
+// -- Unbuild CommonJS Shims --
+import __cjs_url__ from 'url';
+import __cjs_path__ from 'path';
+import __cjs_mod__ from 'module';
+const __filename = __cjs_url__.fileURLToPath(import.meta.url);
+const __dirname = __cjs_path__.dirname(__filename);
+const require = __cjs_mod__.createRequire(import.meta.url);
+
+
+function getVariables(vars) {
+  try {
+    return JSON.parse(vars);
+  } catch (error) {
+    return {};
+  }
+}
+function buildHeaders(req, name, type, config) {
+  if (config?.buildHeaders) {
+    return config.buildHeaders(req, name, type);
+  }
+  if (config?.fetchOptions?.headers) {
+    return config.fetchOptions.headers;
+  }
+  return {};
+}
+function createServerMiddleware(graphqlServer, queries, mutations, config) {
+  const app = express();
+  app.use(express.json());
+  const clients = new Map();
+  function getClient(endpoint) {
+    if (!clients.has(endpoint)) {
+      const client = new GraphQLClient(endpoint);
+      clients.set(endpoint, client);
+    }
+    return clients.get(endpoint);
+  }
+  function getEndpoint(req) {
+    if (config?.buildEndpoint) {
+      return config.buildEndpoint(req);
+    }
+    return graphqlServer;
+  }
+  if (config?.middleware) {
+    app.use(config.middleware);
+  }
+  async function query(req, res) {
+    const name = req.query.name;
+    if (!name || !queries.has(name)) {
+      res.status(404).send();
+      return;
+    }
+    try {
+      const headers = buildHeaders(req, name, "query", config);
+      const variables = getVariables(req.query.variables);
+      const query2 = queries.get(name);
+      const endpoint = getEndpoint(req);
+      const client = getClient(endpoint);
+      const response = await client.rawRequest(query2, variables, headers);
+      if (config?.onQueryResponse) {
+        return config.onQueryResponse(response, req, res);
+      }
+      return res.json(response.data);
+    } catch (e) {
+      if (config?.onQueryError) {
+        return config.onQueryError(e, req, res);
+      }
+      return res.status(500).send();
+    }
+  }
+  async function mutate(req, res) {
+    const name = req.query.name;
+    if (!name || !mutations.has(name)) {
+      res.status(404).send();
+      return;
+    }
+    const mutation = mutations.get(name);
+    try {
+      const headers = buildHeaders(req, name, "mutation", config);
+      const endpoint = getEndpoint(req);
+      const client = getClient(endpoint);
+      const response = await client.request(mutation, req.body, headers);
+      if (config?.onMutationResponse) {
+        return config.onMutationResponse(response, req, res);
+      }
+      return res.json(response);
+    } catch (error) {
+      if (config?.onMutationError) {
+        return config.onMutationError(error, req, res);
+      }
+      return res.status(500).send();
+    }
+  }
+  app.get("/query", query);
+  app.post("/mutate", mutate);
+  return app;
+}
+
+const fragmentImport = require("@graphql-fragment-import/lib/inline-imports");
+function graphqlImport(path, resolver) {
+  return fragmentImport(path, {
+    resolveImport(identifier) {
+      return resolver(identifier);
+    },
+    resolveOptions: {
+      basedir: "./"
+    }
+  });
+}
+
+const typescriptConfig = {
+  exportFragmentSpreadSubTypes: true,
+  preResolveTypes: true,
+  skipTypeNameForRoot: true
+};
+function pluginLoader(name) {
+  if (name === "@graphql-codegen/typescript") {
+    return Promise.resolve(PluginTypescript);
+  } else if (name === "@graphql-codegen/typescript-operations") {
+    return Promise.resolve(PluginTypescriptOperations);
+  } else {
+    return Promise.resolve(PluginSchemaAst);
+  }
+}
+function codegen(graphqlServer, options) {
+  const schemaPath = path.resolve(options.schemaOutputPath, "schema.graphql");
+  function generateSchema() {
+    const schema = options.skipSchemaDownload ? schemaPath : { [graphqlServer]: options.schemaOptions };
+    const configSchemaAst = { ...typescriptConfig, sort: true };
+    return generate({
+      schema,
+      pluginLoader,
+      generates: {
+        [schemaPath]: {
+          plugins: [{ "schema-ast": configSchemaAst }],
+          config: configSchemaAst
+        },
+        [path.resolve(options.typesOutputPath, "graphql-schema.ts")]: {
+          plugins: [{ typescript: typescriptConfig }],
+          config: typescriptConfig
+        }
+      }
+    }, true);
+  }
+  function generateTypes() {
+    const config = {
+      ...typescriptConfig,
+      onlyOperationTypes: true,
+      ...options.schemaOptions || {}
+    };
+    return generate({
+      schema: schemaPath,
+      pluginLoader,
+      documents: path.resolve(options.resolvedQueriesPath, "./*.graphql"),
+      generates: {
+        [path.resolve(options.typesOutputPath, "graphql-operations.ts")]: {
+          plugins: ["typescript", { "typescript-operations": config }],
+          config
+        }
+      }
+    }, true);
+  }
+  return { generateSchema, generateTypes };
+}
+
+const logger = consola.withTag("nuxt-graphql-middleware");
+const PLUGIN_PATH = path.resolve(__dirname, "../dist/plugin.mjs");
+var FileType;
+(function(FileType2) {
+  FileType2["Query"] = "query";
+  FileType2["Mutation"] = "mutation";
+})(FileType || (FileType = {}));
+function resolveGraphqlFile(file, resolver) {
+  return fs.promises.readFile(file).then((buffer) => buffer.toString()).then((source) => graphqlImport(source, resolver));
+}
+function writeSource(dest, type, name, source) {
+  const fileName = `${type}.${name}.graphql`;
+  const out = path.resolve(dest, fileName);
+  return fs.promises.writeFile(out, source);
+}
+function resolveGraphql(files, map, resolver, filesMap, type, outputPath) {
+  return Promise.all(Object.keys(files).map((name) => {
+    const filePath = files[name];
+    const file = resolver(filePath);
+    return resolveGraphqlFile(file, resolver).then((source) => {
+      map.set(name, source);
+      if (outputPath) {
+        writeSource(outputPath, type, name, source);
+      }
+      filesMap.set(file, {
+        type,
+        name,
+        file: filePath
+      });
+    });
+  }));
+}
+const graphqlMiddleware = async function() {
+  const resolver = this.nuxt.resolver.resolveAlias;
+  const options = this.options;
+  const PORT = this.options?.server?.port || 3e3;
+  const provided = this.options.graphqlMiddleware || {};
+  const config = {
+    graphqlServer: provided.graphqlServer || "",
+    typescript: {
+      enabled: !!provided.typescript?.enabled,
+      schemaOptions: provided.typescript?.schemaOptions,
+      resolvedQueriesPath: provided.typescript?.resolvedQueriesPath || provided.outputPath || "",
+      schemaOutputPath: provided.typescript?.schemaOutputPath || "~/schema",
+      typesOutputPath: provided.typescript?.typesOutputPath || "~/types",
+      skipSchemaDownload: !!provided.typescript?.skipSchemaDownload
+    },
+    endpointNamespace: provided.endpointNamespace || "/__graphql_middleware",
+    debug: provided.debug || options.dev,
+    queries: provided.queries || {},
+    mutations: provided.mutations || {},
+    outputPath: provided.outputPath || "",
+    server: provided.server,
+    plugin: {
+      enabled: !!provided.plugin?.enabled,
+      port: 4e3,
+      cacheInBrowser: !!provided.plugin?.cacheInBrowser,
+      cacheInServer: !!provided.plugin?.cacheInServer
+    }
+  };
+  if (config.plugin?.enabled) {
+    this.addPlugin({
+      filename: "graphqlMiddleware.js",
+      src: PLUGIN_PATH,
+      options: {
+        namespace: config.endpointNamespace,
+        port: PORT,
+        cacheInBrowser: config.plugin?.cacheInBrowser ? "true" : "false",
+        cacheInServer: config.plugin?.cacheInServer ? "true" : "false"
+      }
+    });
+  }
+  const fileMap = new Map();
+  const queries = new Map();
+  const mutations = new Map();
+  const outputPath = config.outputPath ? resolver(config.outputPath) : "";
+  await mkdirp(outputPath);
+  const schemaOutputPath = resolver(config.typescript?.schemaOutputPath);
+  const typesOutputPath = resolver(config.typescript?.typesOutputPath);
+  const { generateSchema, generateTypes } = codegen(config.graphqlServer, {
+    resolvedQueriesPath: config.outputPath,
+    schemaOptions: config.typescript?.schemaOptions,
+    skipSchemaDownload: config.typescript?.skipSchemaDownload,
+    schemaOutputPath,
+    typesOutputPath
+  });
+  if (config.typescript?.enabled) {
+    if (!outputPath) {
+      throw new Error("TypeScript enabled, but no outputPath given.");
+    }
+    await mkdirp(schemaOutputPath);
+    await generateSchema();
+  }
+  function build() {
+    logger.log("Building GraphQL files...");
+    return Promise.all([
+      resolveGraphql(config.queries, queries, resolver, fileMap, FileType.Query, outputPath),
+      resolveGraphql(config.mutations, mutations, resolver, fileMap, FileType.Mutation, outputPath)
+    ]).then(() => {
+      logger.success("Finished building GraphQL files");
+      if (config.typescript?.enabled) {
+        return generateTypes().then(() => {
+          logger.success("Finished generating GraphQL TypeScript files.");
+        });
+      }
+    });
+  }
+  function watchFiles() {
+    const ignored = ["node_modules", ".nuxt"];
+    if (config.outputPath) {
+      ignored.push(config.outputPath);
+    }
+    const filesWatcher = chokidar.watch("./**/*.graphql", {
+      ignoreInitial: true,
+      ignored
+    });
+    if (filesWatcher) {
+      logger.info("Watching for query changes");
+      filesWatcher.on("change", () => {
+        build();
+      });
+    }
+    return filesWatcher;
+  }
+  let watcher;
+  if (this.nuxt.options.dev) {
+    this.nuxt.hook("build:done", () => {
+      watcher = watchFiles();
+    });
+    this.nuxt.hook("close", () => {
+      if (watcher) {
+        watcher.close();
+        watcher = void 0;
+      }
+    });
+  }
+  build().then(() => {
+    if (options.debug) {
+      logger.info("Available queries and mutations:");
+      console.table(Array.from(fileMap.entries()).map(([_key, value]) => value));
+    }
+  });
+  this.addServerMiddleware({
+    path: config.endpointNamespace,
+    handler: createServerMiddleware(config.graphqlServer, queries, mutations, config.server)
+  });
+};
+
+export { graphqlMiddleware as default };

package/dist/{runtime/middlewarePlugin.js → plugin.mjs}

@@ -4,7 +4,7 @@ function log(action, path, message) {
     console.log(`[API - ${action}] ${message}: ${path}`);
   }
 }
-export class GraphqlMiddlewarePlugin {
+class GraphqlMiddlewarePlugin {
   constructor(baseURL, headers, useCache, context) {
     this.baseURL = baseURL;
     this.headers = headers || {};
@@ -80,3 +80,18 @@ export class GraphqlMiddlewarePlugin {
     return fetch(this.baseURL + "/mutate?" + params.toString(), fetchOptions).then((response) => response.json());
   }
 }
+const graphqlMiddlewarePlugin = (context, inject) => {
+  const namespace = "<%= options.namespace || '' %>";
+  const port = process?.env?.NUXT_PORT || "<%= options.port %>";
+  const cacheInBrowser = false;
+  const cacheInServer = false;
+  let baseURL = namespace;
+  if (process.server) {
+    baseURL = "http://localhost:" + port + namespace;
+  }
+  const useCache = process.server && cacheInServer || process.client && cacheInBrowser;
+  const plugin = new GraphqlMiddlewarePlugin(baseURL, context.req?.headers, useCache, context);
+  inject("graphql", plugin);
+};
+
+export { GraphqlMiddlewarePlugin, graphqlMiddlewarePlugin as default };

package/dist/types/codegen.d.ts

@@ -0,0 +1,13 @@
+export interface GraphqlMiddlewareCodegenConfig {
+    enabled?: boolean;
+    skipSchemaDownload?: boolean;
+    resolvedQueriesPath: string;
+    schemaOutputPath: string;
+    typesOutputPath: string;
+    schemaOptions: any;
+}
+export default function (graphqlServer: string, options: GraphqlMiddlewareCodegenConfig): {
+    generateSchema: () => Promise<any>;
+    generateTypes: () => Promise<any>;
+};
+//# sourceMappingURL=codegen.d.ts.map

package/dist/types/codegen.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"codegen.d.ts","sourceRoot":"","sources":["../../src/codegen.ts"],"names":[],"mappings":"AAsBA,MAAM,WAAW,8BAA8B;IAC7C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,kBAAkB,CAAC,EAAE,OAAO,CAAA;IAC5B,mBAAmB,EAAE,MAAM,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;IACxB,eAAe,EAAE,MAAM,CAAA;IACvB,aAAa,EAAE,GAAG,CAAA;CACnB;AAED,MAAM,CAAC,OAAO,WACZ,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,8BAA8B;;;EAoDxC"}

package/dist/types/graphqlImport.d.ts

@@ -0,0 +1,2 @@
+export default function (path: string, resolver: any): any;
+//# sourceMappingURL=graphqlImport.d.ts.map

package/dist/types/graphqlImport.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"graphqlImport.d.ts","sourceRoot":"","sources":["../../src/graphqlImport.ts"],"names":[],"mappings":"AAEA,MAAM,CAAC,OAAO,WAAW,IAAI,EAAE,MAAM,EAAE,QAAQ,EAAE,GAAG,OASnD"}

package/dist/types/index.d.ts

@@ -0,0 +1,2 @@
+export * from './module';
+//# sourceMappingURL=index.d.ts.map

package/dist/types/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,UAAU,CAAA"}

package/dist/types/module.d.ts

@@ -0,0 +1,18 @@
+import { Module } from '@nuxt/types';
+import { GraphqlMiddlewarePluginConfig } from './templates/plugin';
+import { GraphqlServerMiddlewareConfig } from './serverMiddleware';
+import { GraphqlMiddlewareCodegenConfig } from './codegen';
+export interface GraphqlMiddlewareConfig {
+    graphqlServer: string;
+    typescript?: GraphqlMiddlewareCodegenConfig;
+    endpointNamespace?: string;
+    debug: boolean;
+    queries: Record<string, string>;
+    mutations: Record<string, string>;
+    outputPath: string;
+    plugin?: GraphqlMiddlewarePluginConfig;
+    server?: GraphqlServerMiddlewareConfig;
+}
+declare const graphqlMiddleware: Module;
+export default graphqlMiddleware;
+//# sourceMappingURL=module.d.ts.map

package/dist/types/module.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"module.d.ts","sourceRoot":"","sources":["../../src/module.ts"],"names":[],"mappings":"AAIA,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAEpC,OAAO,EAAE,6BAA6B,EAAE,MAAM,oBAAoB,CAAA;AAClE,OAAyB,EACvB,6BAA6B,EAC9B,MAAM,oBAAoB,CAAA;AAE3B,OAAgB,EAAE,8BAA8B,EAAE,MAAM,WAAW,CAAA;AAMnE,MAAM,WAAW,uBAAuB;IACtC,aAAa,EAAE,MAAM,CAAA;IACrB,UAAU,CAAC,EAAE,8BAA8B,CAAA;IAC3C,iBAAiB,CAAC,EAAE,MAAM,CAAA;IAC1B,KAAK,EAAE,OAAO,CAAA;IACd,OAAO,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC/B,SAAS,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,MAAM,CAAC,EAAE,6BAA6B,CAAA;IACtC,MAAM,CAAC,EAAE,6BAA6B,CAAA;CACvC;AAiED,QAAA,MAAM,iBAAiB,EAAE,MAgKxB,CAAA;AAED,eAAe,iBAAiB,CAAA"}

package/dist/types/serverMiddleware.d.ts

@@ -0,0 +1,13 @@
+import { Request, RequestHandler } from 'express';
+export interface GraphqlServerMiddlewareConfig {
+    middleware?: RequestHandler;
+    fetchOptions?: any;
+    buildHeaders?: (req: Request, name: string, type: string) => any;
+    buildEndpoint?: (req: Request) => string;
+    onQueryResponse?: any;
+    onQueryError?: any;
+    onMutationResponse?: any;
+    onMutationError?: any;
+}
+export default function createServerMiddleware(graphqlServer: string, queries: Map<string, any>, mutations: Map<string, any>, config?: GraphqlServerMiddlewareConfig): import("express-serve-static-core").Express;
+//# sourceMappingURL=serverMiddleware.d.ts.map

package/dist/types/serverMiddleware.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"serverMiddleware.d.ts","sourceRoot":"","sources":["../../src/serverMiddleware.ts"],"names":[],"mappings":"AAAA,OAAgB,EAAE,OAAO,EAAE,cAAc,EAAY,MAAM,SAAS,CAAA;AAcpE,MAAM,WAAW,6BAA6B;IAC5C,UAAU,CAAC,EAAE,cAAc,CAAA;IAC3B,YAAY,CAAC,EAAE,GAAG,CAAA;IAClB,YAAY,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,EAAE,IAAI,EAAE,MAAM,EAAE,IAAI,EAAE,MAAM,KAAK,GAAG,CAAA;IAChE,aAAa,CAAC,EAAE,CAAC,GAAG,EAAE,OAAO,KAAK,MAAM,CAAA;IACxC,eAAe,CAAC,EAAE,GAAG,CAAA;IACrB,YAAY,CAAC,EAAE,GAAG,CAAA;IAClB,kBAAkB,CAAC,EAAE,GAAG,CAAA;IACxB,eAAe,CAAC,EAAE,GAAG,CAAA;CACtB;AAkBD,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAC5C,aAAa,EAAE,MAAM,EACrB,OAAO,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EACzB,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,EAC3B,MAAM,CAAC,EAAE,6BAA6B,+CA0FvC"}

package/dist/{runtime/middlewarePlugin.d.ts → types/templates/plugin.d.ts}

@@ -1,6 +1,7 @@
-import { Context } from '@nuxt/types';
+import { Context, Plugin } from '@nuxt/types';
 export interface GraphqlMiddlewarePluginConfig {
     enabled?: boolean;
+    port?: number;
     cacheInBrowser?: boolean;
     cacheInServer?: boolean;
 }
@@ -15,12 +16,9 @@ export declare class GraphqlMiddlewarePlugin {
         'Nuxt-Graphql-Middleware-Route': any;
     };
     beforeRequest(fn: Function): void;
-    /**
-     * Perform a GraphQL query via the middleware.
-     */
     query(name: string, variables?: any, headers?: any): Promise<any>;
-    /**
-     * Perform a GraphQL mutation via the middleware.
-     */
     mutate(name: string, variables?: any, headers?: any): Promise<any>;
 }
+declare const graphqlMiddlewarePlugin: Plugin;
+export default graphqlMiddlewarePlugin;
+//# sourceMappingURL=plugin.d.ts.map

package/dist/types/templates/plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plugin.d.ts","sourceRoot":"","sources":["../../../src/templates/plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,OAAO,EAAE,MAAM,EAAE,MAAM,aAAa,CAAA;AAW7C,MAAM,WAAW,6BAA6B;IAC5C,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,cAAc,CAAC,EAAE,OAAO,CAAA;IACxB,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB;AAED,qBAAa,uBAAuB;IAClC,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,GAAG,CAAA;IACZ,eAAe,EAAE,QAAQ,GAAG,SAAS,CAAA;IACrC,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;IACxB,OAAO,EAAE,GAAG,CAAA;gBAGV,OAAO,EAAE,MAAM,EACf,OAAO,EAAE,GAAG,EACZ,QAAQ,EAAE,OAAO,EACjB,OAAO,EAAE,OAAO;IAUlB,oBAAoB;;;IAMpB,aAAa,CAAC,EAAE,EAAE,QAAQ;IAO1B,KAAK,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ;IAgDtD,MAAM,CAAC,IAAI,EAAE,MAAM,EAAE,SAAS,CAAC,EAAE,GAAG,EAAE,OAAO,GAAE,GAAQ;CAuBxD;AAED,QAAA,MAAM,uBAAuB,EAAE,MAyB9B,CAAA;AAED,eAAe,uBAAuB,CAAA"}

package/module.cjs

@@ -0,0 +1,6 @@
+// CommonJS proxy to bypass jiti transforms from nuxt 2 and using native ESM
+module.exports = function(...args) {
+  return import('./dist/module.mjs').then(m => m.default.call(this, ...args))
+}
+
+module.exports.meta = require('./package.json')

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-graphql-middleware",
-  "version": "2.0.0",
+  "version": "2.1.0",
   "description": "Module to perform GraphQL requests as a server middleware.",
   "repository": {
     "type": "git",
@@ -12,31 +12,44 @@
     "email": "me@dulnan.net",
     "url": "https://dulnan.net"
   },
-  "main": "dist/module.js",
-  "types": "dist/types.d.ts",
-  "typings": "./index.d.ts",
+  "exports": {
+    ".": {
+      "import": "./dist/module.mjs",
+      "require": "./module.cjs"
+    },
+    "./dist/*": "./dist/*"
+  },
+  "main": "./module.cjs",
+  "types": "./types/index.d.ts",
   "files": [
-    "dist/"
+    "types/*",
+    "module.cjs",
+    "dist/*.js",
+    "dist/*.mjs",
+    "dist/*.d.ts",
+    "dist/types/*"
   ],
   "scripts": {
-    "build": "siroc build && mkdist --src src/runtime --dist dist/runtime -d --ext js",
-    "dev": "siroc build --watch"
+    "build": "unbuild && npm run generate-types",
+    "dev": "unbuild --stub=true",
+    "generate-types": "tsc -p tsconfig.json --emitDeclarationOnly",
+    "plain-ts": "tsc -p tsconfig.json && tsc -p tsconfig-cjs.json"
   },
   "dependencies": {
-    "@graphql-codegen/cli": "^2.2.0",
-    "@graphql-codegen/schema-ast": "^2.2.0",
-    "@graphql-codegen/typescript": "^2.2.2",
-    "@graphql-codegen/typescript-operations": "^2.1.4",
+    "@graphql-codegen/cli": "^2.3.0",
+    "@graphql-codegen/schema-ast": "^2.4.0",
+    "@graphql-codegen/typescript": "^2.4.1",
+    "@graphql-codegen/typescript-operations": "^2.2.1",
     "@graphql-fragment-import/lib": "^1.2.0",
     "express": "^4.17.1",
-    "graphql": "^15.6.0",
-    "graphql-request": "^3.5.0"
+    "graphql": "^16.0.1",
+    "graphql-request": "^3.6.1"
   },
   "devDependencies": {
     "@nuxt/types": "^2.15.8",
     "@nuxtjs/eslint-config-typescript": "latest",
     "@types/mkdirp": "^1.0.2",
-    "@types/node": "^16.9.6",
+    "@types/node": "^16.11.10",
     "consola": "^2.15.3",
     "eslint": "latest",
     "eslint-config-prettier": "latest",
@@ -44,9 +57,9 @@
     "mkdirp": "^1.0.4",
     "mkdist": "latest",
     "nuxt": "^2.15.8",
-    "prettier": "^2.4.1",
-    "siroc": "^0.16.0",
-    "typescript": "^4.4.3",
+    "prettier": "^2.5.0",
+    "typescript": "^4.5.2",
+    "unbuild": "^0.5.13",
     "vue": "^2.6.14"
   }
 }

package/types/index.d.ts

@@ -0,0 +1,32 @@
+import { GraphqlMiddlewarePlugin } from '../dist/types/templates/plugin'
+import { GraphqlMiddlewareConfig } from '../dist/types/module'
+
+declare module 'vue/types/vue' {
+  interface Vue {
+    readonly $graphql: GraphqlMiddlewarePlugin
+  }
+}
+
+declare module 'vuex/types/index' {
+  interface Store<S> {
+    readonly $graphql: GraphqlMiddlewarePlugin
+  }
+}
+
+declare module '@nuxt/types' {
+  interface NuxtAppOptions {
+    readonly $graphql: GraphqlMiddlewarePlugin
+  }
+  interface Context {
+    readonly $graphql: GraphqlMiddlewarePlugin
+  }
+  interface Configuration {
+    graphqlMiddleware?: GraphqlMiddlewareConfig
+  }
+}
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    graphqlMiddleware?: GraphqlMiddlewareConfig
+  }
+}