nuxt-graphql-middleware 5.2.3 → 5.3.1

package/dist/runtime/components/CodeFrame.d.vue.ts

@@ -0,0 +1,8 @@
+type __VLS_Props = {
+    source: string;
+    line: number;
+    column: number;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/CodeFrame.vue.d.ts

@@ -3,5 +3,6 @@ type __VLS_Props = {
     line: number;
     column: number;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/DevModeOverlay.d.vue.ts

@@ -0,0 +1,4 @@
+import './../css/output.css.js';
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/DevModeOverlay.vue.d.ts

@@ -1,3 +1,4 @@
 import './../css/output.css.js';
-declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ErrorExtensions.d.vue.ts

@@ -0,0 +1,6 @@
+type __VLS_Props = {
+    extensions?: Record<string, unknown>;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ErrorExtensions.vue.d.ts

@@ -1,5 +1,6 @@
 type __VLS_Props = {
     extensions?: Record<string, unknown>;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

package/dist/runtime/components/ErrorGroup.d.vue.ts

@@ -0,0 +1,10 @@
+import type { GraphqlResponseError } from '../types.js';
+type __VLS_Props = {
+    operation: string;
+    operationName: string;
+    errors: GraphqlResponseError[];
+    stack?: string;
+};
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/dist/runtime/components/ErrorGroup.vue.d.ts

@@ -5,5 +5,6 @@ type __VLS_Props = {
     errors: GraphqlResponseError[];
     stack?: string;
 };
-declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const __VLS_export: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
 export default _default;

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

@@ -1,44 +1,5 @@
-import type { FetchOptions } from 'ofetch';
-import type { RequestCacheOptions } from './../types.js';
-import type { GraphqlClientContext } from '#nuxt-graphql-middleware/client-options';
-import type { Query, Mutation } from '#nuxt-graphql-middleware/operation-types';
 import type { NuxtApp } from '#app';
 import type { AppConfig } from 'nuxt/schema';
 import { GraphqlMiddlewareCache } from './ClientCache.js';
-export type GraphqlComposableOptions = {
-    fetchOptions?: FetchOptions;
-    graphqlCaching?: RequestCacheOptions;
-    clientContext?: Partial<GraphqlClientContext>;
-};
-export type GetQueryArgs<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['variables'] extends null ? [K, (null | undefined)?, GraphqlComposableOptions?] : Q['needsVariables'] extends true ? [K, Q['variables'], GraphqlComposableOptions?] : [K, (Q['variables'] | null)?, GraphqlComposableOptions?];
-export type GetMutationArgs<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['needsVariables'] extends true ? [K, M['variables'], GraphqlComposableOptions?] : [K, (M['variables'] | null)?, GraphqlComposableOptions?];
-export type GetQueryResult<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['response'];
-export type GetMutationResult<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['response'];
-export type QueryObjectArgs<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['needsVariables'] extends true ? {
-    name: K;
-    fetchOptions?: FetchOptions;
-    graphqlCaching?: RequestCacheOptions;
-    clientContext?: Partial<GraphqlClientContext>;
-    variables: Q['variables'];
-} : {
-    name: K;
-    variables?: Q['variables'] | null;
-    fetchOptions?: FetchOptions;
-    graphqlCaching?: RequestCacheOptions;
-    clientContext?: Partial<GraphqlClientContext>;
-};
-export type MutationObjectArgs<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['needsVariables'] extends true ? {
-    name: K;
-    variables: M['variables'];
-    fetchOptions?: FetchOptions;
-    clientContext?: Partial<GraphqlClientContext>;
-} : {
-    name: K;
-    variables?: M['variables'] | null;
-    fetchOptions?: FetchOptions;
-    clientContext?: Partial<GraphqlClientContext>;
-};
-export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
-export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
-export declare function encodeContext(context: Record<string, string | null | undefined>): Record<string, string>;
+export { type GraphqlComposableOptions, type GetQueryArgs, type GetMutationArgs, type GetQueryResult, type GetMutationResult, type QueryObjectArgs, type MutationObjectArgs, type PickFrom, type KeysOf, encodeContext, } from './shared-types.js';
 export declare function getOrCreateClientCache(app: NuxtApp, config: AppConfig): GraphqlMiddlewareCache | undefined;

package/dist/runtime/helpers/composables.js

@@ -1,20 +1,11 @@
-import { CLIENT_CONTEXT_PREFIX } from "../settings/index.js";
 import { GraphqlMiddlewareCache } from "./ClientCache.js";
 import {
   clientCacheEnabledAtBuild,
   importMetaServer
 } from "#nuxt-graphql-middleware/config";
-export function encodeContext(context) {
-  return Object.entries(context).reduce(
-    (acc, [key, value]) => {
-      if (typeof value === "string") {
-        acc[CLIENT_CONTEXT_PREFIX + key] = value;
-      }
-      return acc;
-    },
-    {}
-  );
-}
+export {
+  encodeContext
+} from "./shared-types.js";
 export function getOrCreateClientCache(app, config) {
   if (importMetaServer || !clientCacheEnabledAtBuild) {
     return;

package/dist/runtime/helpers/shared-types.d.ts

@@ -0,0 +1,40 @@
+import type { FetchOptions } from 'ofetch';
+import type { RequestCacheOptions } from './../types.js';
+import type { GraphqlClientContext } from '#nuxt-graphql-middleware/client-options';
+import type { Query, Mutation } from '#nuxt-graphql-middleware/operation-types';
+export type GraphqlComposableOptions = {
+    fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
+};
+export type GetQueryArgs<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['variables'] extends null ? [K, (null | undefined)?, GraphqlComposableOptions?] : Q['needsVariables'] extends true ? [K, Q['variables'], GraphqlComposableOptions?] : [K, (Q['variables'] | null)?, GraphqlComposableOptions?];
+export type GetMutationArgs<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['needsVariables'] extends true ? [K, M['variables'], GraphqlComposableOptions?] : [K, (M['variables'] | null)?, GraphqlComposableOptions?];
+export type GetQueryResult<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['response'];
+export type GetMutationResult<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['response'];
+export type QueryObjectArgs<K extends keyof Query, Q extends Query[K] = Query[K]> = Q['needsVariables'] extends true ? {
+    name: K;
+    fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
+    variables: Q['variables'];
+} : {
+    name: K;
+    variables?: Q['variables'] | null;
+    fetchOptions?: FetchOptions;
+    graphqlCaching?: RequestCacheOptions;
+    clientContext?: Partial<GraphqlClientContext>;
+};
+export type MutationObjectArgs<K extends keyof Mutation, M extends Mutation[K] = Mutation[K]> = M['needsVariables'] extends true ? {
+    name: K;
+    variables: M['variables'];
+    fetchOptions?: FetchOptions;
+    clientContext?: Partial<GraphqlClientContext>;
+} : {
+    name: K;
+    variables?: M['variables'] | null;
+    fetchOptions?: FetchOptions;
+    clientContext?: Partial<GraphqlClientContext>;
+};
+export type PickFrom<T, K extends Array<string>> = T extends Array<any> ? T : T extends Record<string, any> ? keyof T extends K[number] ? T : K[number] extends never ? T : Pick<T, K[number]> : T;
+export type KeysOf<T> = Array<T extends T ? (keyof T extends string ? keyof T : never) : never>;
+export declare function encodeContext(context: Record<string, string | null | undefined>): Record<string, string>;

package/dist/runtime/helpers/shared-types.js

@@ -0,0 +1,12 @@
+import { CLIENT_CONTEXT_PREFIX } from "../settings/index.js";
+export function encodeContext(context) {
+  return Object.entries(context).reduce(
+    (acc, [key, value]) => {
+      if (typeof value === "string") {
+        acc[CLIENT_CONTEXT_PREFIX + key] = value;
+      }
+      return acc;
+    },
+    {}
+  );
+}

package/dist/runtime/server/api/doRequest.d.ts

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

package/dist/runtime/server/api/doRequest.js

@@ -0,0 +1,18 @@
+import { defineEventHandler, readBody } from "h3";
+import { doGraphqlRequest } from "../utils/doGraphqlRequest.js";
+export default defineEventHandler(async (event) => {
+  const body = await readBody(event);
+  const { document, variables, operationName } = body || {};
+  if (!document || typeof document !== "string") {
+    return { data: null, errors: [{ message: "Missing or invalid document" }] };
+  }
+  return doGraphqlRequest(
+    {
+      query: document,
+      variables: variables || {},
+      operationName: operationName || void 0
+    },
+    null,
+    event
+  );
+});

package/dist/runtime/server/helpers/index.js

@@ -93,6 +93,6 @@ export function onServerError(serverOptions, event, error, operation, operationN
   throw createError({
     statusCode: 500,
     statusMessage: "Couldn't execute GraphQL query: " + message,
-    data: error && "message" in error ? error.message : error
+    data: error.response?._data
   });
 }

package/dist/runtime/server/mcp/handler.d.ts

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

package/dist/runtime/server/mcp/handler.js

@@ -0,0 +1,63 @@
+import { defineMcpHandler } from "#imports";
+import {
+  mcpServerRoute,
+  includeComposables
+} from "#nuxt-graphql-middleware/mcp";
+import { listOperationsTool } from "./tools/operations-list/index.js";
+import { getOperationTool } from "./tools/operations-get/index.js";
+import { getOperationSourceTool } from "./tools/operations-get-source/index.js";
+import { getFieldUsageTool } from "./tools/operations-get-field-usage/index.js";
+import { executeOperationTool } from "./tools/operations-execute/index.js";
+import { listFragmentsTool } from "./tools/fragments-list/index.js";
+import { getFragmentTool } from "./tools/fragments-get/index.js";
+import { getFragmentSourceTool } from "./tools/fragments-get-source/index.js";
+import { getFragmentsForTypeTool } from "./tools/fragments-list-for-type/index.js";
+import { getSchemaTypeTool } from "./tools/schema-get-type/index.js";
+import { getSchemaTypeDefinitionTool } from "./tools/schema-get-type-definition/index.js";
+import { listSchemaTypesTool } from "./tools/schema-list-types/index.js";
+import { getTypesImplementingInterfaceTool } from "./tools/schema-get-interface-implementors/index.js";
+import { getUnionMembersTool } from "./tools/schema-get-union-members/index.js";
+import { getTypeUsageTool } from "./tools/schema-get-type-usage/index.js";
+import { validateDocumentTool } from "./tools/schema-validate-document/index.js";
+import { executeGraphqlTool } from "./tools/graphql-execute/index.js";
+import { vueGraphqlComposableExampleTool } from "./tools/vue-graphql-composable-example/index.js";
+import { nitroGraphqlServerUtilsExampleTool } from "./tools/nitro-graphql-server-utils-example/index.js";
+import { moduleGetConfigTool } from "./tools/module-get-config/index.js";
+import docsResource from "./resources/docs.js";
+const tools = [
+  // Operation tools.
+  listOperationsTool,
+  getOperationTool,
+  getOperationSourceTool,
+  getFieldUsageTool,
+  // Fragment tools.
+  listFragmentsTool,
+  getFragmentTool,
+  getFragmentSourceTool,
+  getFragmentsForTypeTool,
+  // Schema tools.
+  getSchemaTypeTool,
+  getSchemaTypeDefinitionTool,
+  listSchemaTypesTool,
+  getTypesImplementingInterfaceTool,
+  getUnionMembersTool,
+  getTypeUsageTool,
+  validateDocumentTool,
+  // Execution tools.
+  executeGraphqlTool,
+  executeOperationTool,
+  // Module tools.
+  moduleGetConfigTool
+];
+if (includeComposables) {
+  tools.push(vueGraphqlComposableExampleTool);
+  tools.push(nitroGraphqlServerUtilsExampleTool);
+}
+export default defineMcpHandler({
+  name: "nuxt-graphql-middleware",
+  version: "1.0.0",
+  route: mcpServerRoute,
+  tools,
+  resources: [docsResource],
+  browserRedirect: "/"
+});

package/dist/runtime/server/mcp/resources/docs.d.ts

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

package/dist/runtime/server/mcp/resources/docs.js

@@ -0,0 +1,36 @@
+import { defineMcpResource } from "#imports";
+import { ResourceTemplate } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { docs } from "#nuxt-graphql-middleware/mcp";
+export default defineMcpResource({
+  name: "docs",
+  title: "Documentation",
+  description: "Documentation for nuxt-graphql-middleware composables and utilities.",
+  uri: new ResourceTemplate("docs://{+path}", {
+    list: async () => {
+      return {
+        resources: docs.map((doc) => ({
+          uri: doc.uri,
+          name: doc.name,
+          title: doc.name,
+          mimeType: "text/markdown",
+          description: doc.description
+        }))
+      };
+    }
+  }),
+  metadata: { mimeType: "text/markdown" },
+  handler: async (uri, variables) => {
+    const path = variables.path;
+    const doc = docs.find((d) => d.uri === `docs://${path}`);
+    const content = doc?.content || `Documentation not found for: ${path}`;
+    return {
+      contents: [
+        {
+          uri: uri.toString(),
+          mimeType: "text/markdown",
+          text: content
+        }
+      ]
+    };
+  }
+});

package/dist/runtime/server/mcp/tools/fragments-get/index.d.ts

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

package/dist/runtime/server/mcp/tools/fragments-get/index.js

@@ -0,0 +1,35 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { getFragmentOutputSchema } from "./types.js";
+export const getFragmentTool = defineMcpTool({
+  name: "fragments-get",
+  title: "Get Fragment",
+  description: "Get detailed information about a specific GraphQL fragment. Returns the fragment name, the type it is defined on, file path, and dependencies on other fragments. Use fragments-get-source to get the GraphQL source code.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    fragmentName: z.string().describe("The name of the GraphQL fragment to get details for")
+  },
+  outputSchema: getFragmentOutputSchema,
+  handler: async ({ fragmentName }) => {
+    const response = await fetchFromMcpHandler(
+      "fragments-get",
+      { name: fragmentName }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    const frag = response.fragment;
+    return structuredResult({
+      name: frag.name,
+      typeName: frag.typeName,
+      filePath: frag.relativeFilePath,
+      dependencies: frag.dependencies
+    });
+  }
+});

package/dist/runtime/server/mcp/tools/fragments-get/types.d.ts

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const GetFragmentResponseSchema: z.ZodObject<{
+    fragment: z.ZodNullable<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        relativeFilePath: z.ZodString;
+        source: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getFragmentOutputSchema: {
+    name: z.ZodOptional<z.ZodString>;
+    typeName: z.ZodOptional<z.ZodString>;
+    filePath: z.ZodOptional<z.ZodString>;
+    dependencies: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type GetFragmentResponse = z.infer<typeof GetFragmentResponseSchema>;

package/dist/runtime/server/mcp/tools/fragments-get/types.js

@@ -0,0 +1,13 @@
+import { z } from "zod";
+import { FragmentInfoSchema } from "../fragments-list-for-type/types.js";
+export const GetFragmentResponseSchema = z.object({
+  fragment: FragmentInfoSchema.nullable(),
+  error: z.string().optional().describe("Error message if fragment not found")
+});
+export const getFragmentOutputSchema = {
+  name: z.string().optional().describe("Fragment name"),
+  typeName: z.string().optional().describe("The GraphQL type this fragment is defined on"),
+  filePath: z.string().optional().describe("Path to the file containing the fragment"),
+  dependencies: z.array(z.string()).optional().describe("Names of other fragments this fragment depends on"),
+  error: z.string().optional().describe("Error message if fragment not found")
+};

package/dist/runtime/server/mcp/tools/fragments-get-source/index.d.ts

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

package/dist/runtime/server/mcp/tools/fragments-get-source/index.js

@@ -0,0 +1,34 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getFragmentSourceOutputSchema
+} from "./types.js";
+export const getFragmentSourceTool = defineMcpTool({
+  name: "fragments-get-source",
+  title: "Get Fragment Source",
+  description: "Get the raw GraphQL source code of a fragment. By default returns just the fragment source. Set includeDependencies to true to include all fragment definitions this fragment depends on.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    fragmentName: z.string().describe("The name of the GraphQL fragment to get the source for"),
+    includeDependencies: z.boolean().optional().default(false).describe(
+      "If true, includes all fragment definitions this fragment depends on. Default is false."
+    )
+  },
+  outputSchema: getFragmentSourceOutputSchema,
+  handler: async ({ fragmentName, includeDependencies }) => {
+    const response = await fetchFromMcpHandler(
+      "fragments-get-source",
+      { name: fragmentName, includeDependencies: includeDependencies ?? false }
+    );
+    if (response.error) {
+      return structuredResult({ error: response.error });
+    }
+    return structuredResult({ source: response.source });
+  }
+});

package/dist/runtime/server/mcp/tools/fragments-get-source/types.d.ts

@@ -0,0 +1,10 @@
+import { z } from 'zod';
+export declare const GetFragmentSourceResponseSchema: z.ZodObject<{
+    source: z.ZodNullable<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getFragmentSourceOutputSchema: {
+    source: z.ZodOptional<z.ZodString>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type GetFragmentSourceResponse = z.infer<typeof GetFragmentSourceResponseSchema>;

package/dist/runtime/server/mcp/tools/fragments-get-source/types.js

@@ -0,0 +1,9 @@
+import { z } from "zod";
+export const GetFragmentSourceResponseSchema = z.object({
+  source: z.string().nullable().describe("The GraphQL source code of the fragment"),
+  error: z.string().optional().describe("Error message if fragment not found")
+});
+export const getFragmentSourceOutputSchema = {
+  source: z.string().optional().describe("The GraphQL source code of the fragment"),
+  error: z.string().optional().describe("Error message if fragment not found")
+};

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

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

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

@@ -0,0 +1,36 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import { listFragmentsOutputSchema } from "./types.js";
+export const listFragmentsTool = defineMcpTool({
+  name: "fragments-list",
+  title: "List Fragments",
+  description: "List all GraphQL fragments available in the project. Returns fragment names, the types they are defined on, and file paths.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    nameFilter: z.string().optional().describe(
+      'Optional filter to match fragment names. Can be a plain string for substring matching or a regex pattern (e.g., "^User" to match names starting with "User")'
+    )
+  },
+  outputSchema: listFragmentsOutputSchema,
+  handler: async ({ nameFilter }) => {
+    const response = await fetchFromMcpHandler(
+      "fragments-list",
+      { nameFilter }
+    );
+    const summary = response.fragments.map((frag) => ({
+      name: frag.name,
+      typeName: frag.typeName,
+      filePath: frag.relativeFilePath
+    }));
+    return structuredResult({
+      count: response.fragments.length,
+      fragments: summary
+    });
+  }
+});

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

@@ -0,0 +1,20 @@
+import { z } from 'zod';
+export declare const ListFragmentsResponseSchema: z.ZodObject<{
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        relativeFilePath: z.ZodString;
+        source: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+}, z.core.$strip>;
+export declare const listFragmentsOutputSchema: {
+    count: z.ZodNumber;
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+    }, z.core.$strip>>;
+};
+export type ListFragmentsResponse = z.infer<typeof ListFragmentsResponseSchema>;

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

@@ -0,0 +1,14 @@
+import { z } from "zod";
+import { FragmentInfoSchema } from "../fragments-list-for-type/types.js";
+export const ListFragmentsResponseSchema = z.object({
+  fragments: z.array(FragmentInfoSchema)
+});
+const FragmentSummaryMcpSchema = z.object({
+  name: z.string().describe("Fragment name"),
+  typeName: z.string().describe("The GraphQL type this fragment is defined on"),
+  filePath: z.string().describe("Path to the file relative to the project root")
+});
+export const listFragmentsOutputSchema = {
+  count: z.number().describe("Total number of fragments"),
+  fragments: z.array(FragmentSummaryMcpSchema).describe("List of all fragments")
+};

package/dist/runtime/server/mcp/tools/fragments-list-for-type/index.d.ts

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

package/dist/runtime/server/mcp/tools/fragments-list-for-type/index.js

@@ -0,0 +1,39 @@
+import { z } from "zod";
+import { defineMcpTool } from "#imports";
+import { fetchFromMcpHandler, structuredResult } from "./../../utils/index.js";
+import {
+  getFragmentsForTypeOutputSchema
+} from "./types.js";
+export const getFragmentsForTypeTool = defineMcpTool({
+  name: "fragments-list-for-type",
+  title: "List Fragments for Type",
+  description: "Get all GraphQL fragments defined for a specific type. Returns fragment names, file paths, and dependencies on other fragments. Use fragments-get-source to get the GraphQL source code.",
+  annotations: {
+    readOnlyHint: true,
+    destructiveHint: false,
+    idempotentHint: true,
+    openWorldHint: false
+  },
+  inputSchema: {
+    typeName: z.string().describe(
+      'The name of the GraphQL type to get fragments for (e.g., "User", "Post")'
+    )
+  },
+  outputSchema: getFragmentsForTypeOutputSchema,
+  handler: async ({ typeName }) => {
+    const response = await fetchFromMcpHandler(
+      "fragments-list-for-type",
+      { name: typeName }
+    );
+    if (response.error) {
+      return structuredResult({ fragments: [], error: response.error });
+    }
+    const fragments = response.fragments.map((frag) => ({
+      name: frag.name,
+      typeName: frag.typeName,
+      filePath: frag.relativeFilePath,
+      dependencies: frag.dependencies
+    }));
+    return structuredResult({ fragments });
+  }
+});

package/dist/runtime/server/mcp/tools/fragments-list-for-type/types.d.ts

@@ -0,0 +1,31 @@
+import { z } from 'zod';
+export declare const FragmentInfoSchema: z.ZodObject<{
+    name: z.ZodString;
+    typeName: z.ZodString;
+    filePath: z.ZodString;
+    relativeFilePath: z.ZodString;
+    source: z.ZodString;
+    dependencies: z.ZodArray<z.ZodString>;
+}, z.core.$strip>;
+export declare const GetFragmentsForTypeResponseSchema: z.ZodObject<{
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        relativeFilePath: z.ZodString;
+        source: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>;
+export declare const getFragmentsForTypeOutputSchema: {
+    fragments: z.ZodArray<z.ZodObject<{
+        name: z.ZodString;
+        typeName: z.ZodString;
+        filePath: z.ZodString;
+        dependencies: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>>;
+    error: z.ZodOptional<z.ZodString>;
+};
+export type FragmentInfo = z.infer<typeof FragmentInfoSchema>;
+export type GetFragmentsForTypeResponse = z.infer<typeof GetFragmentsForTypeResponseSchema>;