nuxt-graphql-middleware 3.0.0-beta.2 → 3.0.0-beta.3

package/dist/runtime/composables/index.d.ts

@@ -1,15 +1,15 @@
-import type { Ref } from 'vue';
 import { GraphqlMiddlewareState } from './../../types';
 import type { GraphqlMiddlewareQuery, GraphqlMiddlewareMutation } from '#build/nuxt-graphql-middleware';
-declare type GraphqlMiddlewareQueryName = keyof GraphqlMiddlewareQuery;
-declare type GraphqlMiddlewareMutationName = keyof GraphqlMiddlewareMutation;
-declare type GraphqlMiddlewareOperationMap = GraphqlMiddlewareQuery | GraphqlMiddlewareMutation;
-declare type GetArgs<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareOperationMap> = M[T][0] extends null ? [T] : M[T][1] extends false ? [T, M[T][0]] : [T, M[T][0]?];
-declare type GraphqlResponse<T> = {
+type GraphqlMiddlewareQueryName = keyof GraphqlMiddlewareQuery;
+type GraphqlMiddlewareMutationName = keyof GraphqlMiddlewareMutation;
+type GetQueryArgs<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T][0] extends null ? [T] : M[T][1] extends false ? [T, M[T][0]] : [T, M[T][0]?];
+type GetMutationArgs<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T][0] extends null ? [T] : M[T][1] extends false ? [T, M[T][0]] : [T, M[T][0]?];
+type GraphqlResponse<T> = {
     data: T;
 };
-declare type GetResult<T, M> = M[T] extends undefined ? undefined : GraphqlResponse<M[T][2]>;
-export declare const useGraphqlState: () => Ref<GraphqlMiddlewareState>;
-export declare function useGraphqlQuery<T extends GraphqlMiddlewareQueryName>(...args: GetArgs<T, GraphqlMiddlewareQuery>): Promise<GetResult<T, GraphqlMiddlewareQuery>>;
-export declare function useGraphqlMutation<T extends GraphqlMiddlewareMutationName>(...args: GetArgs<T, GraphqlMiddlewareMutation>): Promise<GetResult<T, GraphqlMiddlewareMutation>>;
+type GetQueryResult<T extends GraphqlMiddlewareQueryName, M extends GraphqlMiddlewareQuery> = M[T] extends undefined ? undefined : GraphqlResponse<M[T][2]>;
+type GetMutationResult<T extends GraphqlMiddlewareMutationName, M extends GraphqlMiddlewareMutation> = M[T] extends undefined ? undefined : GraphqlResponse<M[T][2]>;
+export declare const useGraphqlState: () => GraphqlMiddlewareState;
+export declare function useGraphqlQuery<T extends GraphqlMiddlewareQueryName>(...args: GetQueryArgs<T, GraphqlMiddlewareQuery>): Promise<GetQueryResult<T, GraphqlMiddlewareQuery>>;
+export declare function useGraphqlMutation<T extends GraphqlMiddlewareMutationName>(...args: GetMutationArgs<T, GraphqlMiddlewareMutation>): Promise<GetMutationResult<T, GraphqlMiddlewareMutation>>;
 export {};

package/dist/runtime/composables/index.mjs

@@ -1,36 +1,28 @@
-import { useNuxtApp, useRuntimeConfig } from "#imports";
+import { buildRequestParams } from "./../helpers/index.mjs";
+import { useRuntimeConfig } from "#imports";
 function getEndpoint(operation, operationName) {
   const config = useRuntimeConfig();
   return `${config?.public?.["nuxt-graphql-middleware"]?.serverApiPrefix}/${operation}/${operationName}`;
 }
+const state = {
+  fetchOptions: {}
+};
 export const useGraphqlState = () => {
-  const nuxtApp = useNuxtApp();
-  return nuxtApp?._graphql_middleware;
+  return state;
 };
 export function useGraphqlQuery(...args) {
   const name = args[0];
   if (typeof name !== "string") {
     return Promise.reject(new Error("Invalid query name"));
   }
-  const variables = args[1] || {};
-  let params = {};
-  const queryFallback = Object.keys(variables).some((key) => {
-    const valueType = typeof variables[key];
-    return valueType === "function" || valueType === "object";
-  });
-  if (queryFallback) {
-    params.__variables = JSON.stringify(variables);
-  } else {
-    params = variables;
-  }
-  const state = useGraphqlState();
+  const state2 = useGraphqlState();
   return $fetch(getEndpoint("query", name), {
-    params,
-    ...state.value.fetchOptions
+    params: buildRequestParams(args[1]),
+    ...state2.fetchOptions
   });
 }
 export function useGraphqlMutation(...args) {
-  const state = useGraphqlState();
+  const state2 = useGraphqlState();
   const name = args[0];
   const body = args[1] || {};
   if (typeof name !== "string") {
@@ -39,6 +31,6 @@ export function useGraphqlMutation(...args) {
   return $fetch(getEndpoint("mutation", name), {
     method: "post",
     body,
-    ...state.value.fetchOptions
+    ...state2.fetchOptions
   });
 }

package/dist/runtime/helpers/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * Type check for falsy values.
+ *
+ * Used as the callback for array.filter, e.g.
+ * items.filter(falsy)
+ */
+export declare function falsy<T>(value: T): value is NonNullable<T>;
+/**
+ * Get the parameters for the GraphQL middleware query.
+ */
+export declare function buildRequestParams(variables?: Record<string, any> | undefined | null): Record<string, any>;

package/dist/runtime/helpers/index.mjs

@@ -0,0 +1,16 @@
+export function falsy(value) {
+  return value !== null && value !== void 0;
+}
+export function buildRequestParams(variables) {
+  if (!variables) {
+    return {};
+  }
+  for (const key in variables) {
+    if (typeof variables[key] !== "string") {
+      return {
+        __variables: JSON.stringify(variables)
+      };
+    }
+  }
+  return variables;
+}

package/dist/runtime/serverHandler/helpers/getModuleConfig.d.ts

@@ -0,0 +1,6 @@
+import type { GraphqlMiddlewareConfig } from './../../../types';
+/**
+ * Due to nuxt's architecture, we have to manually load the runtime configuration.
+ * This is only done for the first time and we cache the config locally.
+ */
+export declare function getModuleConfig(): Promise<GraphqlMiddlewareConfig>;

package/dist/runtime/serverHandler/helpers/getModuleConfig.mjs

@@ -0,0 +1,15 @@
+import { loadNuxtConfig } from "@nuxt/kit";
+import { useRuntimeConfig } from "#imports";
+let moduleConfig = null;
+export function getModuleConfig() {
+  if (moduleConfig) {
+    return Promise.resolve(moduleConfig);
+  }
+  const { graphqlMiddleware } = useRuntimeConfig();
+  return loadNuxtConfig({
+    cwd: graphqlMiddleware.rootDir
+  }).then((v) => {
+    moduleConfig = v.graphqlMiddleware;
+    return v.graphqlMiddleware;
+  });
+}

package/dist/runtime/serverHandler/helpers/index.d.ts

@@ -1,2 +1,18 @@
-export declare function parseQuery(query: Record<string, any>): void;
-export declare function parseJSON(object: object): string;
+import { QueryObject } from 'ufo';
+import type { H3Event } from 'h3';
+import type { FetchOptions } from 'ofetch';
+import type { GraphqlMiddlewareConfig } from './../../../types';
+import { GraphqlMiddlewareOperation } from './../../../types';
+export declare function queryParamToVariables(query: QueryObject): any;
+/**
+ * Get the URL of the GraphQL endpoint.
+ */
+export declare function getEndpoint(moduleConfig: GraphqlMiddlewareConfig, event: H3Event, operation: GraphqlMiddlewareOperation, operationName: string): string;
+/**
+ * Get the options for the $fetch request to the GraphQL server.
+ */
+export declare function getFetchOptions(moduleConfig: GraphqlMiddlewareConfig, event: H3Event, operation: GraphqlMiddlewareOperation, operationName: string): FetchOptions;
+/**
+ * Assure that the request is valid.
+ */
+export declare function validateRequest(method?: string, operation?: GraphqlMiddlewareOperation, name?: string, documents?: Record<string, Record<string, string>>): void;

package/dist/runtime/serverHandler/helpers/index.mjs

@@ -1,4 +1,63 @@
-export function parseQuery(query) {
+import { createError } from "h3";
+import { GraphqlMiddlewareOperation } from "./../../../types";
+export function queryParamToVariables(query) {
+  try {
+    if (query.__variables && typeof query.__variables === "string") {
+      return JSON.parse(query.__variables);
+    }
+  } catch (_e) {
+  }
+  return query;
 }
-export function parseJSON(object) {
+export function getEndpoint(moduleConfig, event, operation, operationName) {
+  if (typeof moduleConfig.graphqlEndpoint === "string") {
+    return moduleConfig.graphqlEndpoint;
+  } else if (typeof moduleConfig.graphqlEndpoint === "function") {
+    const endpoint = moduleConfig.graphqlEndpoint(
+      event,
+      operation,
+      operationName
+    );
+    if (endpoint && typeof endpoint === "string") {
+      return endpoint;
+    }
+  }
+  throw new Error("Failed to determine endpoint for GraphQL server.");
+}
+export function getFetchOptions(moduleConfig, event, operation, operationName) {
+  if (typeof moduleConfig.serverFetchOptions === "function") {
+    return moduleConfig.serverFetchOptions(event, operation, operationName) || {};
+  } else if (typeof moduleConfig.serverFetchOptions === "object") {
+    return moduleConfig.serverFetchOptions;
+  }
+  return {};
+}
+function throwError(statusMessage, statusCode = 400) {
+  throw createError({
+    statusCode,
+    statusMessage
+  });
+}
+export function validateRequest(method, operation, name, documents) {
+  if (method !== "POST" && method !== "GET") {
+    throwError("Method not allowed.", 405);
+  }
+  if (operation !== GraphqlMiddlewareOperation.Query && operation !== GraphqlMiddlewareOperation.Mutation) {
+    throwError("Unknown operation.");
+  }
+  if (method === "POST" && operation !== GraphqlMiddlewareOperation.Mutation) {
+    throwError("Queries must be a GET request.");
+  }
+  if (method === "GET" && operation !== GraphqlMiddlewareOperation.Query) {
+    throwError("Mutations must be a POST request.");
+  }
+  if (!name) {
+    throwError("Missing name for operation.");
+  }
+  if (!documents) {
+    throwError("Failed to load GraphQL documents", 500);
+  }
+  if (!documents[operation][name]) {
+    throwError(`Operation "${operation}" with name "${name}" not found.`);
+  }
 }

package/dist/runtime/serverHandler/index.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("h3").EventHandler<unknown>;
+declare const _default: import("h3").EventHandler<any>;
 export default _default;

package/dist/runtime/serverHandler/index.mjs

@@ -5,89 +5,45 @@ import {
   getMethod,
   readBody
 } from "h3";
-import { loadNuxtConfig } from "@nuxt/kit";
-import { useRuntimeConfig } from "#imports";
-import operations from "#graphql-documents";
-var GraphqlMiddlewareOperation = /* @__PURE__ */ ((GraphqlMiddlewareOperation2) => {
-  GraphqlMiddlewareOperation2["Query"] = "query";
-  GraphqlMiddlewareOperation2["Mutation"] = "mutation";
-  return GraphqlMiddlewareOperation2;
-})(GraphqlMiddlewareOperation || {});
-let moduleConfig = null;
-function getModuleConfig() {
-  if (moduleConfig) {
-    return Promise.resolve(moduleConfig);
-  }
-  const { graphqlMiddleware } = useRuntimeConfig();
-  return loadNuxtConfig({
-    cwd: graphqlMiddleware.rootDir
-  }).then((v) => {
-    moduleConfig = v.graphqlMiddleware;
-    return v.graphqlMiddleware;
-  });
-}
-function queryParamToVariables(query) {
-  try {
-    if (query.__variables && typeof query.__variables === "string") {
-      return JSON.parse(query.__variables);
-    }
-  } catch (_e) {
-  }
-  return query;
-}
-function getEndpoint(moduleConfig2, event, operation, operationName) {
-  if (typeof moduleConfig2.graphqlEndpoint === "string") {
-    return moduleConfig2.graphqlEndpoint;
-  }
-  return moduleConfig2.graphqlEndpoint(event, operation, operationName);
-}
-function getFetchOptions(moduleConfig2, event, operation, operationName) {
-  if (typeof moduleConfig2.serverFetchOptions === "function") {
-    return moduleConfig2.serverFetchOptions(event, operation, operationName) || {};
-  } else if (typeof moduleConfig2.serverFetchOptions === "object") {
-    return moduleConfig2.serverFetchOptions;
-  }
-  return {};
-}
+import {
+  queryParamToVariables,
+  getEndpoint,
+  getFetchOptions,
+  validateRequest
+} from "./helpers";
+import { getModuleConfig } from "./helpers/getModuleConfig.mjs";
+import { GraphqlMiddlewareOperation } from "./../../types";
+import { documents } from "#graphql-documents";
 export default defineEventHandler(async (event) => {
   const method = getMethod(event);
   const operation = event.context.params.operation;
-  if (method === "POST" && operation !== "mutation" /* Mutation */) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Mutations must be a POST request."
-    });
-  }
-  if (method === "GET" && operation !== "query" /* Query */) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: "Queries must be a GET request."
-    });
-  }
   const name = event.context.params.name;
-  const query = operations[operation][name];
-  if (!query) {
-    throw createError({
-      statusCode: 400,
-      statusMessage: `Operation "${operation}" with name "${name} not found."`
-    });
-  }
+  validateRequest(method, operation, name, documents);
+  const query = documents[operation][name];
   const config = await getModuleConfig();
   const endpoint = getEndpoint(config, event, operation, name);
   const fetchOptions = getFetchOptions(config, event, operation, name);
-  const variables = operation === "query" /* Query */ ? queryParamToVariables(getQuery(event)) : readBody(event);
-  return $fetch(endpoint, {
+  const variables = operation === GraphqlMiddlewareOperation.Query ? queryParamToVariables(getQuery(event)) : await readBody(event);
+  return $fetch.raw(endpoint, {
     method: "POST",
     body: {
       query,
       variables
     },
     ...fetchOptions
+  }).then((response) => {
+    if (config.onServerResponse) {
+      return config.onServerResponse(event, response, operation, name);
+    }
+    return response._data;
   }).catch((err) => {
+    if (config.onServerError) {
+      return config.onServerError(event, err, operation, name);
+    }
     throw createError({
       statusCode: 500,
       statusMessage: "Couldn't execute GraphQL query.",
-      data: err && "message" in err ? err.mess : err
+      data: err && "message" in err ? err.message : err
     });
   });
 });

package/dist/types.d.ts

@@ -8,4 +8,4 @@ declare module '@nuxt/schema' {
 }
 
 
-export { default } from './module'
+export { ModuleHooks, ModuleOptions, default } from './module'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "nuxt-graphql-middleware",
-  "version": "3.0.0-beta.2",
+  "version": "3.0.0-beta.3",
   "license": "MIT",
   "type": "module",
   "exports": {
@@ -16,34 +16,51 @@
   ],
   "scripts": {
     "prepack": "nuxt-module-build",
-    "dev": "nuxi dev playground",
+    "dev": "nuxi dev playground --trace-warnings",
     "dev:build": "nuxi build playground",
     "dev:prepare": "nuxt-module-build --stub && nuxi prepare playground",
     "typedoc": "typedoc --plugin typedoc-plugin-markdown --out foobar",
     "docs:dev": "vitepress dev docs --port 5000",
     "docs:build": "vitepress build docs",
-    "docs:serve": "vitepress serve docs --port 5000"
+    "docs:serve": "vitepress serve docs --port 5000",
+    "cypress": "cypress run --e2e",
+    "cypress:open": "cypress open --e2e",
+    "test": "vitest",
+    "test:ci": "vitest run",
+    "test:coverage": "vitest run --coverage"
   },
   "dependencies": {
-    "@graphql-codegen/cli": "^2.11.8",
+    "@graphql-codegen/cli": "^2.15.0",
     "@graphql-codegen/schema-ast": "^2.5.1",
-    "@graphql-codegen/typescript": "^2.7.3",
-    "@graphql-codegen/typescript-generic-sdk": "^3.0.1",
-    "@graphql-codegen/typescript-operations": "^2.5.3",
+    "@graphql-codegen/typescript": "^2.8.3",
+    "@graphql-codegen/typescript-generic-sdk": "^3.0.4",
+    "@graphql-codegen/typescript-operations": "^2.5.8",
     "@graphql-fragment-import/lib": "^2.0.0",
-    "@nuxt/kit": "^3.0.0-rc.8"
+    "@graphql-tools/utils": "^9.1.1",
+    "@nuxt/kit": "^3.0.0",
+    "cli-table": "^0.3.11",
+    "inquirer": "^9.1.4"
   },
   "devDependencies": {
-    "@nuxt/module-builder": "latest",
-    "@nuxtjs/eslint-config-typescript": "latest",
-    "eslint": "latest",
+    "@nuxt/module-builder": "^0.2.1",
+    "@nuxt/schema": "^3.0.0",
+    "@nuxt/test-utils": "^3.0.0",
+    "@nuxtjs/eslint-config-typescript": "^12.0.0",
+    "@types/capture-console": "^1.0.1",
+    "@types/cli-table": "^0.3.1",
+    "@types/inquirer": "^9.0.3",
+    "@vitest/coverage-c8": "^0.25.3",
+    "cypress": "^11.2.0",
+    "eslint": "^8.29.0",
     "eslint-config-prettier": "^8.5.0",
     "eslint-plugin-prettier": "^4.2.1",
-    "jsdoc-to-markdown": "^7.1.1",
-    "nuxt": "^3.0.0-rc.8",
-    "prettier": "^2.7.1",
-    "typedoc": "^0.23.14",
-    "typedoc-plugin-markdown": "^3.13.5",
-    "vitepress": "^1.0.0-alpha.13"
+    "jsdoc-to-markdown": "^8.0.0",
+    "nuxt": "^3.0.0",
+    "prettier": "^2.8.0",
+    "strip-ansi": "^7.0.1",
+    "typedoc": "^0.23.21",
+    "typedoc-plugin-markdown": "^3.14.0",
+    "vitepress": "^1.0.0-alpha.29",
+    "vitest": "^0.25.3"
   }
 }

package/dist/runtime/plugin.d.ts

@@ -1,2 +0,0 @@
-declare const _default: any;
-export default _default;

package/dist/runtime/plugin.mjs

@@ -1,9 +0,0 @@
-import { ref, useNuxtApp, defineNuxtPlugin } from "#imports";
-export default defineNuxtPlugin(() => {
-  const nuxtApp = useNuxtApp();
-  if (!nuxtApp?._graphql_middleware) {
-    nuxtApp._graphql_middleware = ref({
-      fetchOptions: {}
-    });
-  }
-});