nuxt-graphql-middleware 1.2.2 → 2.0.4

package/dist/module.mjs

@@ -0,0 +1,324 @@
+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.d.ts")]: {
+          plugins: [{ typescript: typescriptConfig }],
+          config: typescriptConfig
+        }
+      }
+    }, true);
+  }
+  function generateTypes() {
+    const config = {
+      ...typescriptConfig,
+      onlyOperationTypes: true
+    };
+    return generate({
+      schema: schemaPath,
+      pluginLoader,
+      documents: path.resolve(options.resolvedQueriesPath, "./*.graphql"),
+      generates: {
+        [path.resolve(options.typesOutputPath, "graphql-operations.d.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/plugin.mjs

@@ -0,0 +1,97 @@
+const IS_DEV = process.env.NODE_ENV === "development";
+function log(action, path, message) {
+  if (IS_DEV) {
+    console.log(`[API - ${action}] ${message}: ${path}`);
+  }
+}
+class GraphqlMiddlewarePlugin {
+  constructor(baseURL, headers, useCache, context) {
+    this.baseURL = baseURL;
+    this.headers = headers || {};
+    this.context = context;
+    if (useCache) {
+      this.cache = new Map();
+    }
+  }
+  getPluginHeaderValue() {
+    return {
+      "Nuxt-Graphql-Middleware-Route": this.context?.route?.fullPath || ""
+    };
+  }
+  beforeRequest(fn) {
+    this.beforeRequestFn = fn;
+  }
+  query(name, variables, headers = {}) {
+    const params = new URLSearchParams({
+      name,
+      variables: JSON.stringify(variables || {})
+    });
+    const url = this.baseURL + "/query?" + params.toString();
+    if (this.cache?.has(url)) {
+      log("query", url, "Loading from cache");
+      return Promise.resolve(this.cache.get(url));
+    }
+    log("query", url, "Fetching");
+    let fetchOptions = {
+      method: "GET",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+        ...this.headers,
+        ...this.getPluginHeaderValue()
+      }
+    };
+    if (this.beforeRequestFn) {
+      fetchOptions = this.beforeRequestFn(this.context, fetchOptions);
+    }
+    return fetch(url, fetchOptions).then((response) => {
+      if (response.ok) {
+        return response.json();
+      }
+      throw new Error("Server Error");
+    }).then((data) => {
+      if (this.cache && this.cache.size > 30) {
+        const key = this.cache.keys().next().value;
+        this.cache.delete(key);
+      }
+      this.cache?.set(url, data);
+      return data;
+    });
+  }
+  mutate(name, variables, headers = {}) {
+    const params = new URLSearchParams({
+      name
+    });
+    let fetchOptions = {
+      method: "POST",
+      credentials: "include",
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+        ...this.headers,
+        ...this.getPluginHeaderValue()
+      },
+      body: JSON.stringify(variables)
+    };
+    if (this.beforeRequestFn) {
+      fetchOptions = this.beforeRequestFn(this.context, fetchOptions);
+    }
+    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.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;;;EAmDxC"}

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/{lib/types/module/index.d.ts → dist/types/module.d.ts}

@@ -1,6 +1,6 @@
 import { Module } from '@nuxt/types';
-import { GraphqlServerMiddlewareConfig } from './../serverMiddleware';
-import { GraphqlMiddlewarePluginConfig } from './../plugin';
+import { GraphqlMiddlewarePluginConfig } from './templates/plugin';
+import { GraphqlServerMiddlewareConfig } from './serverMiddleware';
 import { GraphqlMiddlewareCodegenConfig } from './codegen';
 export interface GraphqlMiddlewareConfig {
     graphqlServer: string;
@@ -13,5 +13,6 @@ export interface GraphqlMiddlewareConfig {
     plugin?: GraphqlMiddlewarePluginConfig;
     server?: GraphqlServerMiddlewareConfig;
 }
-export declare const graphqlMiddleware: Module;
-//# sourceMappingURL=index.d.ts.map
+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/{lib/types/serverMiddleware/index.d.ts → dist/types/serverMiddleware.d.ts}

@@ -10,4 +10,4 @@ export interface GraphqlServerMiddlewareConfig {
     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=index.d.ts.map
+//# 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/{lib/types/plugin/index.d.ts → dist/types/templates/plugin.d.ts}

@@ -1,6 +1,7 @@
 import { Context, Plugin } from '@nuxt/types';
 export interface GraphqlMiddlewarePluginConfig {
     enabled?: boolean;
+    port?: number;
     cacheInBrowser?: boolean;
     cacheInServer?: boolean;
 }
@@ -20,4 +21,4 @@ export declare class GraphqlMiddlewarePlugin {
 }
 declare const graphqlMiddlewarePlugin: Plugin;
 export default graphqlMiddlewarePlugin;
-//# sourceMappingURL=index.d.ts.map
+//# 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,51 +1,65 @@
 {
   "name": "nuxt-graphql-middleware",
-  "version": "1.2.2",
+  "version": "2.0.4",
   "description": "Module to perform GraphQL requests as a server middleware.",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/dulnan/nuxt-graphql-middleware.git"
+  },
   "license": "MIT",
   "author": {
     "name": "Jan Hug",
-    "url": "https://dulnan.net",
-    "email": "me@dulnan.net"
+    "email": "me@dulnan.net",
+    "url": "https://dulnan.net"
   },
-  "scripts": {
-    "build": "tsc -p tsconfig-esm.json && tsc -p tsconfig-cjs.json"
+  "exports": {
+    ".": {
+      "import": "./dist/module.mjs",
+      "require": "./module.cjs"
+    },
+    "./dist/*": "./dist/*"
   },
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/dulnan/nuxt-graphql-middleware.git"
-  },
-  "main": "./lib/cjs/index.js",
-  "module": "./lib/esm/index.js",
-  "types": "./types.d.ts",
+  "main": "./module.cjs",
+  "types": "./types/index.d.ts",
   "files": [
-    "lib/",
-    "types.d.ts"
+    "types/*",
+    "module.cjs",
+    "dist/*.js",
+    "dist/*.mjs",
+    "dist/*.d.ts",
+    "dist/types/*"
   ],
+  "scripts": {
+    "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": "^1.20.1",
-    "@graphql-codegen/schema-ast": "^1.18.1",
-    "@graphql-codegen/typescript": "^1.21.0",
-    "@graphql-codegen/typescript-operations": "^1.17.14",
-    "@graphql-fragment-import/lib": "^1.1.1",
+    "@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.5.0",
-    "graphql-request": "^3.4.0"
+    "graphql": "^15.6.0",
+    "graphql-request": "^3.6.1"
   },
   "devDependencies": {
-    "@nuxt/types": "^2.14.12",
+    "@nuxt/types": "^2.15.8",
     "@nuxtjs/eslint-config-typescript": "latest",
-    "@types/mkdirp": "^1.0.1",
-    "@types/node": "^14.14.22",
-    "consola": "^2.15.0",
+    "@types/mkdirp": "^1.0.2",
+    "@types/node": "^16.11.9",
+    "consola": "^2.15.3",
     "eslint": "latest",
     "eslint-config-prettier": "latest",
     "eslint-plugin-prettier": "latest",
-    "globby": "^11.0.2",
     "mkdirp": "^1.0.4",
-    "nuxt": "^2.14.12",
-    "prettier": "^2.2.1",
-    "typescript": "^4.1.3",
-    "vue": "^2.6.12"
+    "mkdist": "latest",
+    "nuxt": "^2.15.8",
+    "prettier": "^2.4.1",
+    "typescript": "^4.5.2",
+    "unbuild": "^0.5.13",
+    "vue": "^2.6.14"
   }
 }

package/{types.d.ts → types/index.d.ts}

@@ -1,11 +1,5 @@
-import Vue from 'vue'
-import '@nuxt/types'
-import { GraphqlMiddlewarePlugin } from './lib/types/plugin'
-import { GraphqlMiddlewareConfig } from './lib/types/module'
-
-declare module '*.vue' {
-  export default Vue
-}
+import { GraphqlMiddlewarePlugin } from '../dist/types/templates/plugin'
+import { GraphqlMiddlewareConfig } from '../dist/types/module'
 
 declare module 'vue/types/vue' {
   interface Vue {
@@ -14,7 +8,6 @@ declare module 'vue/types/vue' {
 }
 
 declare module 'vuex/types/index' {
-  // @ts-ignore
   interface Store<S> {
     readonly $graphql: GraphqlMiddlewarePlugin
   }
@@ -31,3 +24,9 @@ declare module '@nuxt/types' {
     graphqlMiddleware?: GraphqlMiddlewareConfig
   }
 }
+
+declare module '@nuxt/schema' {
+  interface NuxtConfig {
+    graphqlMiddleware?: GraphqlMiddlewareConfig
+  }
+}

package/lib/cjs/index.js

@@ -1,5 +0,0 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.default = void 0;
-var module_1 = require("./module");
-Object.defineProperty(exports, "default", { enumerable: true, get: function () { return module_1.graphqlMiddleware; } });