nuxt-graphql-middleware 5.2.2 → 5.3.0

package/dist/runtime/server/mcp/tools/schema-get-union-members/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getUnionMembersOutputSchema
+} from "./types.js";
+export const getUnionMembersTool = defineMcpTool({
+  name: "schema-get-union-members",
+  title: "Get Union Members",
+  description: "Get all types that are members of a GraphQL union. Returns the member type names and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    unionName: z.string().describe('The name of the GraphQL union (e.g., "SearchResult")')
+  },
+  outputSchema: getUnionMembersOutputSchema,
+  handler: async ({ unionName }) => {
+    const response = await fetchFromMcpHandler(
+      "schema-get-union-members",
+      { name: unionName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      unionName: response.unionName,
+      count: response.members.length,
+      members: response.members
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-get-union-members/types.d.ts

@@ -0,0 +1,24 @@
+import { z } from 'zod';
+export declare const UnionMemberSchema: z.ZodObject<{
+    name: z.ZodString;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetUnionMembersResponseSchema: z.ZodObject<{
+    unionName: z.ZodString;
+    members: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getUnionMembersOutputSchema: {
+    unionName: z.ZodOptional<z.ZodString>;
+    count: z.ZodOptional<z.ZodNumber>;
+    members: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type UnionMember = z.infer<typeof UnionMemberSchema>;
+export type GetUnionMembersResponse = z.infer<typeof GetUnionMembersResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-get-union-members/types.js

@@ -0,0 +1,16 @@
+import { z } from "zod";
+export const UnionMemberSchema = z.object({
+  name: z.string().describe("Type name"),
+  description: z.string().nullable().describe("Type description")
+});
+export const GetUnionMembersResponseSchema = z.object({
+  unionName: z.string().describe("The union name"),
+  members: z.array(UnionMemberSchema),
+  error: z.string().optional().describe("Error message if union not found")
+});
+export const getUnionMembersOutputSchema = {
+  unionName: z.string().optional().describe("The union name"),
+  count: z.number().optional().describe("Number of union members"),
+  members: z.array(UnionMemberSchema).optional().describe("Types that are part of the union"),
+  error: z.string().optional().describe("Error message if union not found")
+};

package/dist/runtime/server/mcp/tools/schema-list-types/index.d.ts

@@ -0,0 +1 @@
+export declare const listSchemaTypesTool: any;

package/dist/runtime/server/mcp/tools/schema-list-types/index.js

@@ -0,0 +1,37 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  listSchemaTypesOutputSchema
+} from "./types.js";
+export const listSchemaTypesTool = defineMcpTool({
+  name: "schema-list-types",
+  title: "List Schema Types",
+  description: "List all types in the GraphQL schema. Can be filtered by kind (OBJECT, INPUT_OBJECT, ENUM, UNION, INTERFACE, SCALAR). Returns type names, kinds, and descriptions.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    kind: z.enum(["OBJECT", "INPUT_OBJECT", "ENUM", "UNION", "INTERFACE", "SCALAR"]).optional().describe(
+      "Optional filter by type kind. If not provided, returns all types."
+    )
+  },
+  outputSchema: listSchemaTypesOutputSchema,
+  handler: async ({ kind }) => {
+    const params = {};
+    if (kind) {
+      params.kind = kind;
+    }
+    const response = await fetchFromMcpHandler(
+      "schema-list-types",
+      Object.keys(params).length > 0 ? params : void 0
+    );
+    return structuredResult({
+      count: response.types.length,
+      types: response.types
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-list-types/types.d.ts

@@ -0,0 +1,53 @@
+import { z } from 'zod';
+export declare const SchemaTypeKindFilterSchema: z.ZodEnum<{
+    OBJECT: "OBJECT";
+    INPUT_OBJECT: "INPUT_OBJECT";
+    ENUM: "ENUM";
+    UNION: "UNION";
+    INTERFACE: "INTERFACE";
+    SCALAR: "SCALAR";
+}>;
+export declare const SchemaTypeSummarySchema: z.ZodObject<{
+    name: z.ZodString;
+    kind: z.ZodEnum<{
+        OBJECT: "OBJECT";
+        INPUT_OBJECT: "INPUT_OBJECT";
+        ENUM: "ENUM";
+        UNION: "UNION";
+        INTERFACE: "INTERFACE";
+        SCALAR: "SCALAR";
+    }>;
+    description: z.ZodNullable<z.ZodString>;
+}, z.core.$strip>;
+export declare const ListSchemaTypesResponseSchema: z.ZodObject<{
+    types: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            OBJECT: "OBJECT";
+            INPUT_OBJECT: "INPUT_OBJECT";
+            ENUM: "ENUM";
+            UNION: "UNION";
+            INTERFACE: "INTERFACE";
+            SCALAR: "SCALAR";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const listSchemaTypesOutputSchema: {
+    count: z.ZodNumber;
+    types: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        kind: z.ZodEnum<{
+            OBJECT: "OBJECT";
+            INPUT_OBJECT: "INPUT_OBJECT";
+            ENUM: "ENUM";
+            UNION: "UNION";
+            INTERFACE: "INTERFACE";
+            SCALAR: "SCALAR";
+        }>;
+        description: z.ZodNullable<z.ZodString>;
+    }, z.core.$strip>>;
+};
+export type SchemaTypeKindFilter = z.infer<typeof SchemaTypeKindFilterSchema>;
+export type SchemaTypeSummary = z.infer<typeof SchemaTypeSummarySchema>;
+export type ListSchemaTypesResponse = z.infer<typeof ListSchemaTypesResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-list-types/types.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const SchemaTypeKindFilterSchema = z.enum([
+  "OBJECT",
+  "INPUT_OBJECT",
+  "ENUM",
+  "UNION",
+  "INTERFACE",
+  "SCALAR"
+]);
+export const SchemaTypeSummarySchema = z.object({
+  name: z.string().describe("Type name"),
+  kind: SchemaTypeKindFilterSchema.describe("The kind of GraphQL type"),
+  description: z.string().nullable().describe("Type description")
+});
+export const ListSchemaTypesResponseSchema = z.object({
+  types: z.array(SchemaTypeSummarySchema)
+});
+export const listSchemaTypesOutputSchema = {
+  count: z.number().describe("Total number of types"),
+  types: z.array(SchemaTypeSummarySchema).describe("List of schema types")
+};

package/dist/runtime/server/mcp/tools/schema-validate-document/index.d.ts

@@ -0,0 +1 @@
+export declare const validateDocumentTool: any;

package/dist/runtime/server/mcp/tools/schema-validate-document/index.js

@@ -0,0 +1,31 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  validateDocumentOutputSchema
+} from "./types.js";
+export const validateDocumentTool = defineMcpTool({
+  name: "schema-validate-document",
+  title: "Validate Document",
+  description: "Validate a raw GraphQL document against the schema. Checks for syntax errors, unknown fields, type mismatches, and other validation issues. Use this to verify a GraphQL query, mutation, or fragment before saving it to a file.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    document: z.string().describe("The raw GraphQL document source to validate")
+  },
+  outputSchema: validateDocumentOutputSchema,
+  handler: async (args) => {
+    const response = await fetchFromMcpHandler(
+      "schema-validate-document",
+      { document: args.document }
+    );
+    return structuredResult({
+      valid: response.valid,
+      errors: response.errors
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/schema-validate-document/types.d.ts

@@ -0,0 +1,26 @@
+import { z } from 'zod';
+export declare const ValidateDocumentRequestSchema: z.ZodObject<{
+    document: z.ZodString;
+}, z.core.$strip>;
+export declare const ValidateDocumentResponseSchema: z.ZodObject<{
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const validateDocumentOutputSchema: {
+    valid: z.ZodBoolean;
+    errors: z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+    }, z.core.$strip>>;
+};
+export type ValidateDocumentRequest = z.infer<typeof ValidateDocumentRequestSchema>;
+export type ValidateDocumentResponse = z.infer<typeof ValidateDocumentResponseSchema>;

package/dist/runtime/server/mcp/tools/schema-validate-document/types.js

@@ -0,0 +1,21 @@
+import { z } from "zod";
+export const ValidateDocumentRequestSchema = z.object({
+  document: z.string().describe("The raw GraphQL document source to validate")
+});
+const ValidationErrorSchema = z.object({
+  message: z.string().describe("The error message"),
+  locations: z.array(
+    z.object({
+      line: z.number().describe("Line number (1-indexed)"),
+      column: z.number().describe("Column number (1-indexed)")
+    })
+  ).optional().describe("Source locations where the error occurred")
+});
+export const ValidateDocumentResponseSchema = z.object({
+  valid: z.boolean().describe("Whether the document is valid"),
+  errors: z.array(ValidationErrorSchema).describe("List of validation errors, empty if valid")
+});
+export const validateDocumentOutputSchema = {
+  valid: z.boolean().describe("Whether the document is valid"),
+  errors: z.array(ValidationErrorSchema).describe("List of validation errors, empty if valid")
+};

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/index.d.ts

@@ -0,0 +1 @@
+export declare const vueGraphqlComposableExampleTool: any;

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/index.js

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  composableExamplesOutputSchema
+} from "./types.js";
+export const vueGraphqlComposableExampleTool = defineMcpTool({
+  name: "vue-graphql-composable-example",
+  title: "Vue GraphQL Composable Examples",
+  description: "Generate usage examples for Vue composables (useGraphqlQuery, useAsyncGraphqlQuery, useGraphqlMutation, etc.) for a specific GraphQL operation. Returns code examples with mock variable data.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    operationName: z.string().describe(
+      'The name of the GraphQL operation to generate examples for (e.g., "getUsers", "createPost")'
+    )
+  },
+  outputSchema: composableExamplesOutputSchema,
+  handler: async ({ operationName }) => {
+    const response = await fetchFromMcpHandler(
+      "vue-graphql-composable-example",
+      { name: operationName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({
+      examples: response.examples,
+      imports: response.imports
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/types.d.ts

@@ -0,0 +1,49 @@
+import { z } from 'zod';
+/**
+ * Schema for a single usage example.
+ */
+export declare const ComposableExampleSchema: z.ZodObject<{
+    code: z.ZodString;
+    description: z.ZodString;
+    documentationUrl: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Schema for an import entry.
+ */
+export declare const ImportEntrySchema: z.ZodObject<{
+    typeName: z.ZodString;
+    description: z.ZodString;
+}, z.core.$strip>;
+/**
+ * Response schema for the handler.
+ */
+export declare const GetComposableExamplesResponseSchema: z.ZodObject<{
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        description: z.ZodString;
+        documentationUrl: z.ZodString;
+    }, z.core.$strip>>>;
+    imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+/**
+ * MCP output schema.
+ */
+export declare const composableExamplesOutputSchema: {
+    examples: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        code: z.ZodString;
+        description: z.ZodString;
+        documentationUrl: z.ZodString;
+    }, z.core.$strip>>>;
+    imports: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        typeName: z.ZodString;
+        description: z.ZodString;
+    }, z.core.$strip>>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type ComposableExample = z.infer<typeof ComposableExampleSchema>;
+export type ImportEntry = z.infer<typeof ImportEntrySchema>;
+export type GetComposableExamplesResponse = z.infer<typeof GetComposableExamplesResponseSchema>;

package/dist/runtime/server/mcp/tools/vue-graphql-composable-example/types.js

@@ -0,0 +1,24 @@
+import { z } from "zod";
+export const ComposableExampleSchema = z.object({
+  code: z.string().describe("The code example showing how to use the composable"),
+  description: z.string().describe("A description of what this example demonstrates"),
+  documentationUrl: z.string().describe("URL to the documentation for this composable")
+});
+export const ImportEntrySchema = z.object({
+  typeName: z.string().describe("The name of the type to import"),
+  description: z.string().describe(
+    'What this type is used for (e.g., "Variables type", "Response type", "Input type", "Enum type")'
+  )
+});
+export const GetComposableExamplesResponseSchema = z.object({
+  examples: z.array(ComposableExampleSchema).optional(),
+  imports: z.array(ImportEntrySchema).optional(),
+  error: z.string().optional()
+});
+export const composableExamplesOutputSchema = {
+  examples: z.array(ComposableExampleSchema).optional().describe("Array of usage examples for the operation"),
+  imports: z.array(ImportEntrySchema).optional().describe(
+    "Array of types that can be imported from #graphql-operations for this operation"
+  ),
+  error: z.string().optional().describe("Error message if the operation was not found")
+};

package/dist/runtime/server/mcp/utils/index.d.ts

@@ -0,0 +1,48 @@
+import { z } from 'zod';
+import type { GraphqlServerResponse } from '../../../types.js';
+/**
+ * Shared Zod schema for GraphQL errors.
+ */
+export declare const GraphqlErrorSchema: z.ZodObject<{
+    message: z.ZodString;
+    locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        line: z.ZodNumber;
+        column: z.ZodNumber;
+    }, z.core.$strip>>>;
+    path: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+/**
+ * Shared output schema for GraphQL execution results.
+ */
+export declare const graphqlExecutionOutputSchema: {
+    data: z.ZodNullable<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    errors: z.ZodOptional<z.ZodArray<z.ZodObject<{
+        message: z.ZodString;
+        locations: z.ZodOptional<z.ZodArray<z.ZodObject<{
+            line: z.ZodNumber;
+            column: z.ZodNumber;
+        }, z.core.$strip>>>;
+        path: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        extensions: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>>>;
+};
+/**
+ * Extracts GraphQL error response from a fetch error.
+ */
+export declare function extractErrorResponse(e: unknown): GraphqlServerResponse<any> | null;
+/**
+ * Fetches data from the MCP dev handler using POST.
+ */
+export declare function fetchFromMcpHandler<T>(tool: string, params?: Record<string, unknown>): Promise<T>;
+/**
+ * Creates an MCP tool result with both content (for backwards compatibility)
+ * and structuredContent (required when outputSchema is defined).
+ */
+export declare function structuredResult<T extends Record<string, unknown>>(data: T): {
+    content: {
+        type: "text";
+        text: string;
+    }[];
+    structuredContent: T;
+};

package/dist/runtime/server/mcp/utils/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { devServerUrl } from "#nuxt-graphql-middleware/mcp";
+export const GraphqlErrorSchema = z.object({
+  message: z.string().describe("The error message"),
+  locations: z.array(
+    z.object({
+      line: z.number().describe("Line number"),
+      column: z.number().describe("Column number")
+    })
+  ).optional().describe("Source locations where the error occurred"),
+  path: z.array(z.union([z.string(), z.number()])).optional().describe("Path to the field that caused the error"),
+  extensions: z.record(z.string(), z.unknown()).optional().describe("Additional error metadata")
+});
+export const graphqlExecutionOutputSchema = {
+  data: z.record(z.string(), z.unknown()).nullable().describe("The GraphQL response data, or null if the request failed"),
+  errors: z.array(GraphqlErrorSchema).optional().describe("GraphQL errors if any occurred")
+};
+export function extractErrorResponse(e) {
+  if (typeof e === "object" && e && "response" in e && e.response && typeof e.response === "object" && "_data" in e.response && typeof e.response._data === "object") {
+    return e.response._data;
+  }
+  return null;
+}
+export async function fetchFromMcpHandler(tool, params) {
+  return await $fetch(`${devServerUrl}/__nuxt_graphql_middleware/mcp`, {
+    method: "POST",
+    body: { tool, ...params }
+  });
+}
+export function structuredResult(data) {
+  return {
+    content: [{ type: "text", text: JSON.stringify(data, null, 2) }],
+    structuredContent: data
+  };
+}

package/dist/runtime/server/utils/useGraphqlMutation.d.ts

@@ -1,5 +1,5 @@
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
-import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/composables.js';
+import { type GetMutationArgs, type MutationObjectArgs, type GetMutationResult } from './../../helpers/shared-types.js';
 import type { Mutation } from '#nuxt-graphql-middleware/operation-types';
 /**
  * Performs a GraphQL mutation.

package/dist/runtime/server/utils/useGraphqlMutation.js

@@ -1,6 +1,6 @@
 import {
   encodeContext
-} from "./../../helpers/composables.js";
+} from "./../../helpers/shared-types.js";
 import { performRequest } from "./index.js";
 export function useGraphqlMutation(...args) {
   const [name, body, fetchOptions = {}, clientContext = {}] = typeof args[0] === "string" ? [args[0], args[1], args[2]?.fetchOptions, args[2]?.clientContext] : [

package/dist/runtime/server/utils/useGraphqlQuery.d.ts

@@ -1,5 +1,5 @@
 import type { GraphqlResponse } from '#nuxt-graphql-middleware/response';
-import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/composables.js';
+import { type GetQueryArgs, type QueryObjectArgs, type GetQueryResult } from './../../helpers/shared-types.js';
 import type { Query } from '#nuxt-graphql-middleware/operation-types';
 /**
  * Performs a GraphQL query.

package/dist/runtime/server/utils/useGraphqlQuery.js

@@ -1,6 +1,6 @@
 import {
   encodeContext
-} from "./../../helpers/composables.js";
+} from "./../../helpers/shared-types.js";
 import { encodeVariables } from "./../../helpers/queryEncoding.js";
 import { performRequest } from "./index.js";
 export function useGraphqlQuery(...args) {

package/dist/runtime/types.d.ts

@@ -90,7 +90,7 @@ export type GraphqlMiddlewareRequestContext<C extends ContextType = ContextType>
 };
 export type GraphqlMiddlewareGraphqlEndpointMethod<C extends ContextType> = (event: H3Event, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => string | Promise<string> | undefined;
 export type GraphqlMiddlewareServerFetchOptionsMethod<C extends ContextType> = (event: H3Event, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => FetchOptions | Promise<FetchOptions>;
-export type GraphqlMiddlewareOnServerResponseMethod<ServerReponse, T, C extends ContextType> = (event: H3Event, response: FetchResponse<ServerReponse>, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => T | Promise<T>;
+export type GraphqlMiddlewareOnServerResponseMethod<ServerReponse, T, C extends ContextType> = (event: H3Event, response: FetchResponse<ServerReponse>, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => NoInfer<T> | NoInfer<Promise<T>>;
 export type GraphqlMiddlewareOnServerErrorMethod<C extends ContextType> = (event: H3Event, error: FetchError, operation?: string | null, operationName?: string | null, context?: GraphqlMiddlewareRequestContext<C> | null) => any | Promise<any>;
 export type GraphqlMiddlewareDoRequestMethodContext<C extends ContextType> = {
     /**