nitro-graphql 0.0.3 → 0.0.5

package/dist/_virtual/rolldown_runtime.js

@@ -0,0 +1,37 @@
+//#region rolldown:runtime
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __esm = (fn, res) => function() {
+	return fn && (res = (0, fn[__getOwnPropNames(fn)[0]])(fn = 0)), res;
+};
+var __commonJS = (cb, mod) => function() {
+	return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
+};
+var __export = (target, all) => {
+	for (var name in all) __defProp(target, name, {
+		get: all[name],
+		enumerable: true
+	});
+};
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+//#endregion
+export { __commonJS, __esm, __export, __toCommonJS, __toESM };

package/dist/client-codegen.js

@@ -1,11 +1,12 @@
-import { consola } from "consola";
+import { preset } from "./node_modules/.pnpm/@graphql-codegen_import-types-preset@3.0.1_graphql@16.11.0/node_modules/@graphql-codegen/import-types-preset/esm/index.js";
 import { codegen } from "@graphql-codegen/core";
 import { plugin } from "@graphql-codegen/typescript";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import { consola as consola$1 } from "consola";
 import { defu } from "defu";
 import { parse } from "graphql";
-import { plugin as plugin$1 } from "@graphql-codegen/typescript-generic-sdk";
-import { plugin as plugin$2 } from "@graphql-codegen/typescript-operations";
+import { plugin as plugin$1 } from "@graphql-codegen/typescript-operations";
+import { plugin as plugin$2 } from "@graphql-codegen/typescript-generic-sdk";
 import { GraphQLFileLoader } from "@graphql-tools/graphql-file-loader";
 import { loadDocuments } from "@graphql-tools/load";
 
@@ -31,13 +32,12 @@ async function loadGraphQLDocuments(patterns) {
 		else throw e;
 	}
 }
-async function generateClientTypes(schema, patterns, config = {}, outputPath) {
-	const docs = await loadGraphQLDocuments(patterns);
+async function generateClientTypes(schema, docs, config = {}, outputPath) {
 	if (docs.length === 0) {
-		consola.info("[graphql] No client GraphQL files found. Skipping client type generation.");
-		return "";
+		consola$1.info("[graphql] No client GraphQL files found. Skipping client type generation.");
+		return false;
 	}
-	consola.info(`[graphql] Found ${docs.length} client GraphQL documents`);
+	consola$1.info(`[graphql] Found ${docs.length} client GraphQL documents`);
 	const defaultConfig = {
 		documentMode: "string",
 		emitLegacyCommonJSImports: false,
@@ -64,22 +64,57 @@ async function generateClientTypes(schema, patterns, config = {}, outputPath) {
 			plugins: [
 				{ pluginContent: {} },
 				{ typescript: {} },
+				{ typescriptOperations: {} }
+			],
+			pluginMap: {
+				pluginContent: { plugin: pluginContent },
+				typescript: { plugin },
+				typescriptOperations: { plugin: plugin$1 }
+			}
+		});
+		const sdkOutput = await preset.buildGeneratesSection({
+			baseOutputDir: outputPath || "client-types.generated.ts",
+			schema: parse(printSchemaWithDirectives(schema)),
+			documents: [...docs],
+			config: {
+				documentMode: "string",
+				pureMagicComment: true,
+				strictScalars: true,
+				scalars: {
+					DateTime: "Date",
+					JSON: "any",
+					UUID: "string",
+					NonEmptyString: "string",
+					Currency: "string"
+				}
+			},
+			presetConfig: { typesPath: "#graphql/client" },
+			plugins: [
+				{ pluginContent: {} },
 				{ typescriptOperations: {} },
 				{ typescriptGenericSdk: { rawRequest: false } }
 			],
 			pluginMap: {
 				pluginContent: { plugin: pluginContent },
-				typescript: { plugin },
-				typescriptOperations: { plugin: plugin$2 },
-				typescriptGenericSdk: { plugin: plugin$1 }
+				typescriptOperations: { plugin: plugin$1 },
+				typescriptGenericSdk: { plugin: plugin$2 }
 			}
 		});
-		return output;
+		const results = await Promise.all(sdkOutput.map(async (config$1) => {
+			return {
+				file: config$1.filename,
+				content: await codegen(config$1)
+			};
+		}));
+		return {
+			types: output,
+			sdk: results[0]?.content || ""
+		};
 	} catch (error) {
-		consola.warn("[graphql] Client type generation failed:", error);
-		return "";
+		consola$1.warn("[graphql] Client type generation failed:", error);
+		return false;
 	}
 }
 
 //#endregion
-export { generateClientTypes };
+export { generateClientTypes, loadGraphQLDocuments };

package/dist/codegen.d.ts

@@ -1,13 +1,7 @@
+import { CodegenServerConfig } from "./types.js";
 import { GraphQLSchema } from "graphql";
 
 //#region src/codegen.d.ts
-interface CodegenServerConfig {
-  contextType?: string;
-  scalars?: Record<string, any>;
-  defaultMapper?: string;
-  mapperTypeSuffix?: string;
-  [key: string]: any;
-}
 declare function generateTypes(schema: GraphQLSchema, config?: CodegenServerConfig, outputPath?: string): Promise<string>;
 //#endregion
-export { CodegenServerConfig, generateTypes };
+export { generateTypes };

package/dist/codegen.js

@@ -2,6 +2,7 @@ import { codegen } from "@graphql-codegen/core";
 import * as typescriptPlugin from "@graphql-codegen/typescript";
 import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
+import consola from "consola";
 import { defu } from "defu";
 import { parse } from "graphql";
 import { CurrencyResolver, DateTimeResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
@@ -99,7 +100,7 @@ type ResolverReturnTypeObject<T extends object> = {
 			typescriptResolvers: typescriptResolversPlugin
 		}
 	}).catch((e) => {
-		console.warn("[nitro-graphql] Code generation error:", e);
+		consola.withTag("graphql").error("Error generating types:", e);
 		return "";
 	});
 	return output;

package/dist/ecosystem/nuxt.d.ts

@@ -0,0 +1,7 @@
+import * as _nuxt_schema2 from "@nuxt/schema";
+
+//#region src/ecosystem/nuxt.d.ts
+interface ModuleOptions {}
+declare const _default: _nuxt_schema2.NuxtModule<ModuleOptions, ModuleOptions, false>;
+//#endregion
+export { ModuleOptions, _default as default };

package/dist/ecosystem/nuxt.js

@@ -0,0 +1,29 @@
+import { join } from "pathe";
+import { addImportsDir, defineNuxtModule } from "@nuxt/kit";
+
+//#region src/ecosystem/nuxt.ts
+var nuxt_default = defineNuxtModule({
+	meta: {
+		name: "nitro-graphql-nuxt",
+		configKey: "nitro-graphql-nuxt",
+		compatibility: { nuxt: ">=3.16.0" }
+	},
+	defaults: {},
+	setup: (options, nuxt) => {
+		nuxt.hooks.hook("prepare:types", (options$1) => {
+			options$1.references.push({ path: "types/nitro-graphql-client.d.ts" });
+			options$1.tsConfig ??= {};
+			options$1.tsConfig.compilerOptions ??= {};
+			options$1.tsConfig.compilerOptions.paths ??= {};
+			options$1.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
+			options$1.tsConfig.include = options$1.tsConfig.include || [];
+			options$1.tsConfig.include.push("./types/nitro-graphql-client.d.ts");
+		});
+		nuxt.options.alias = nuxt.options.alias || {};
+		nuxt.options.alias["#graphql/client"] = join(nuxt.options.buildDir, "types/nitro-graphql-client.d.ts");
+		addImportsDir(join(nuxt.options.srcDir, "graphql"));
+	}
+});
+
+//#endregion
+export { nuxt_default as default };

package/dist/graphql.d.ts

@@ -0,0 +1,13 @@
+import { NitroGraphQLOptions } from "./types.js";
+import { NitroConfig } from "nitropack";
+
+//#region src/graphql.d.ts
+declare module 'nitropack' {
+  interface NitroRuntimeHooks {}
+  interface NitroRuntimeConfig {}
+}
+declare module 'nitropack/config' {
+  function defineNitroConfig(config: NitroConfig & {
+    graphql?: NitroGraphQLOptions;
+  }): NitroConfig;
+}

package/dist/index.d.ts

@@ -1,15 +1,6 @@
-import { NitroGraphQLOptions } from "./types.js";
-import * as nitropack1 from "nitropack";
+import * as nitropack5 from "nitropack";
 
 //#region src/index.d.ts
-declare module 'nitropack' {
-  interface NitroOptions {
-    graphqlYoga?: NitroGraphQLOptions;
-  }
-  interface NitroRuntimeConfig {
-    graphqlYoga?: NitroGraphQLOptions;
-  }
-}
-declare const _default: nitropack1.NitroModule;
+declare const _default: nitropack5.NitroModule;
 //#endregion
 export { _default as default };

package/dist/index.js

@@ -1,159 +1,106 @@
-import { devmode } from "./dev.js";
-import { relativeWithDot } from "./utils.js";
-import { dirname, join, resolve } from "pathe";
+import { relativeWithDot, scanDefs, scanResolvers } from "./utils/index.js";
+import { clientTypeGeneration, serverTypeGeneration } from "./utils/server-type-generation.js";
+import { rollupConfig } from "./rollup.js";
+import { writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { watch } from "chokidar";
 import { defineNitroModule } from "nitropack/kit";
+import { dirname, join, resolve } from "pathe";
 
 //#region src/index.ts
 var src_default = defineNitroModule({
-	name: "nitro:graphql-yoga",
+	name: "nitro-graphql",
 	async setup(nitro) {
-		if (!nitro.options.dev) {
-			nitro.options.rollupConfig ??= {};
-			if (nitro.options.rollupConfig) {
-				nitro.options.rollupConfig.plugins ??= [];
-				const originalExternal = nitro.options.rollupConfig.external;
-				nitro.options.rollupConfig.external = (id, parentId, isResolved) => {
-					if (id.startsWith("./dev")) return true;
-					if (id.startsWith("./prerender") && !nitro.options.prerender) return true;
-					if (typeof originalExternal === "function") return originalExternal(id, parentId, isResolved);
-					if (Array.isArray(originalExternal)) return originalExternal.includes(id);
-					return false;
-				};
-			}
-		}
-		const options = {
-			endpoint: "/api/graphql",
-			playground: true,
-			cors: false,
-			cacheHeaders: {
-				enabled: true,
-				maxAge: 604800
-			},
-			client: {
-				enabled: nitro.options.framework?.name === "nuxt",
-				outputPath: void 0,
-				watchPatterns: void 0,
-				config: {
-					documentMode: "string",
-					emitLegacyCommonJSImports: false,
-					useTypeImports: true,
-					enumsAsTypes: true
-				}
-			},
-			...nitro.options.graphqlYoga,
-			...nitro.options.runtimeConfig?.graphqlYoga
+		nitro.graphql ||= {
+			buildDir: "",
+			watchDirs: [],
+			clientDir: ""
 		};
-		devmode(nitro, options);
-		nitro.options.virtual ??= {};
-		nitro.options.virtual["#nitro-graphql/context"] = () => `
-export type { GraphQLContext } from 'nitro-graphql/context'
-`;
-		nitro.options.handlers = nitro.options.handlers || [];
-		const endpoint = options.endpoint || "/api/graphql";
-		if (nitro.options.prerender || nitro.options.dev) {
-			const { prerender } = await import("./prerender.js");
-			await prerender(nitro, options);
+		const graphqlBuildDir = resolve(nitro.options.buildDir, "graphql");
+		nitro.graphql.buildDir = graphqlBuildDir;
+		const watchDirs = [];
+		switch (nitro.options.framework.name) {
+			case "nuxt":
+				watchDirs.push(join(nitro.options.rootDir, "app", "graphql"));
+				nitro.graphql.clientDir = resolve(nitro.options.rootDir, "app", "graphql");
+				break;
+			default:
 		}
+		watch(watchDirs, {
+			persistent: true,
+			ignoreInitial: true,
+			ignored: nitro.options.ignore
+		}).on("all", async (event, path) => {
+			if (path.endsWith(".graphql") || path.endsWith(".gql")) await clientTypeGeneration(nitro, path);
+		});
+		const tsConfigPath = resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath);
+		const tsconfigDir = dirname(tsConfigPath);
+		const typesDir = resolve(nitro.options.buildDir, "types");
+		const defs = await scanDefs(nitro);
+		nitro.scanDefs = defs;
+		const resolvers = await scanResolvers(nitro);
+		nitro.scanResolvers = resolvers;
+		nitro.hooks.hook("dev:start", async () => {
+			const defs$1 = await scanDefs(nitro);
+			nitro.scanDefs = defs$1;
+			const resolvers$1 = await scanResolvers(nitro);
+			nitro.scanResolvers = resolvers$1;
+		});
+		await rollupConfig(nitro);
+		await serverTypeGeneration(nitro);
+		await clientTypeGeneration(nitro, nitro.graphql.clientDir);
+		const endpoint = "/api/graphql";
+		const runtime = fileURLToPath(new URL("routes", import.meta.url));
 		nitro.options.handlers.push({
 			route: endpoint,
-			handler: "#nitro-graphql/handler",
+			handler: join(runtime, "graphql"),
 			method: "get"
 		});
 		nitro.options.handlers.push({
 			route: endpoint,
-			handler: "#nitro-graphql/handler",
+			handler: join(runtime, "graphql"),
 			method: "post"
 		});
 		nitro.options.handlers.push({
 			route: endpoint,
-			handler: "#nitro-graphql/handler",
+			handler: join(runtime, "graphql"),
 			method: "options"
 		});
-		nitro.options.handlers.push({
-			route: `${endpoint}/health`,
-			handler: "#nitro-graphql/health",
-			method: "get"
-		});
-		nitro.options.virtual["#nitro-graphql/health"] = () => `
-import { defineEventHandler, setResponseStatus } from 'h3'
-
-export default defineEventHandler(async (event) => {
-  try {
-    const response = await $fetch('${endpoint}', {
-      method: 'POST',
-      body: {
-        query: 'query Health { __typename }',
-        operationName: 'Health',
-      },
-      headers: {
-        'Content-Type': 'application/json',
-        'Accept': 'application/json',
-      },
-    })
-    
-    if (response && typeof response === 'object' && 'data' in response) {
-      return {
-        status: 'healthy',
-        message: 'GraphQL server is running',
-        timestamp: new Date().toISOString(),
-      }
-    }
-    
-    throw new Error('Invalid response from GraphQL server')
-  } catch (error) {
-    setResponseStatus(event, 503)
-    return {
-      status: 'unhealthy',
-      message: error.message || 'GraphQL server is not responding',
-      timestamp: new Date().toISOString(),
-    }
-  }
-})
-`;
 		if (nitro.options.imports) nitro.options.imports.presets.push({
 			from: "nitro-graphql/utils",
 			imports: ["defineResolver", "defineYogaConfig"]
 		});
-		const tsConfigPath = resolve(nitro.options.buildDir, nitro.options.typescript.tsconfigPath);
-		const tsconfigDir = dirname(tsConfigPath);
-		const typesDir = resolve(nitro.options.buildDir, "types");
+		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
+			const manualChunks = rollupConfig$1.output?.manualChunks;
+			const chunkFiles = rollupConfig$1.output?.chunkFileNames;
+			if (!rollupConfig$1.output.inlineDynamicImports) rollupConfig$1.output.manualChunks = (id, meta) => {
+				if (id.endsWith(".graphql") || id.endsWith(".gql")) return "schemas";
+				if (id.endsWith(".resolver.ts")) return "resolvers";
+				if (typeof manualChunks === "function") return manualChunks(id, meta);
+				return void 0;
+			};
+			rollupConfig$1.output.chunkFileNames = (chunkInfo) => {
+				if (chunkInfo.moduleIds && chunkInfo.moduleIds.some((id) => id.includes("/graphql/") || id.includes(".graphql") || id.includes(".resolver.ts") || id.includes(".gql"))) return `chunks/graphql/[name].mjs`;
+				if (typeof chunkFiles === "function") return chunkFiles(chunkInfo);
+				return `chunks/_/[name].mjs`;
+			};
+		});
+		const graphqlDtsContent = `// Auto-generated by nitro-graphql
+import type { Resolvers as Test } from './nitro-graphql-server.d.ts'
+
+declare module 'nitro-graphql/types' {
+  interface Resolvers extends Test {}
+}
+`;
+		writeFileSync(join(typesDir, "graphql.d.ts"), graphqlDtsContent);
 		nitro.hooks.hook("types:extend", (types) => {
 			types.tsConfig ||= {};
 			types.tsConfig.compilerOptions ??= {};
 			types.tsConfig.compilerOptions.paths ??= {};
-			types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, join(typesDir, "graphql-types.generated.ts"))];
-			types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, join(typesDir, "graphql-client.generated.ts"))];
+			types.tsConfig.compilerOptions.paths["#graphql/server"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts"))];
+			types.tsConfig.compilerOptions.paths["#graphql/client"] = [relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts"))];
 			types.tsConfig.include = types.tsConfig.include || [];
-			types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, "graphql-client.generated.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql-types.generated.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql.d.ts")));
-		});
-		const graphqlPath = join(nitro.options.srcDir, "graphql");
-		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig) => {
-			rollupConfig.external = rollupConfig.external || [];
-			const codegenExternals = [
-				"@graphql-codegen/core",
-				"@graphql-codegen/typescript",
-				"@graphql-codegen/typescript-resolvers",
-				"@graphql-codegen/typescript-operations",
-				"@graphql-codegen/typescript-generic-sdk",
-				"@graphql-tools/graphql-file-loader",
-				"@graphql-tools/load"
-			];
-			if (Array.isArray(rollupConfig.external)) rollupConfig.external.push(...codegenExternals);
-			else if (typeof rollupConfig.external === "function") {
-				const originalExternal = rollupConfig.external;
-				rollupConfig.external = (id, parent, isResolved) => {
-					if (codegenExternals.some((external) => id.includes(external))) return true;
-					return originalExternal(id, parent, isResolved);
-				};
-			}
-			const originalChunkFileNames = rollupConfig.output.chunkFileNames;
-			rollupConfig.output.chunkFileNames = (chunk) => {
-				const allIds = chunk.moduleIds || [];
-				const hasGraphQLResolverFile = allIds.some((id) => id.includes(graphqlPath) && !id.includes("node_modules") && !id.includes("#nitro-graphql") && (id.endsWith(".ts") || id.endsWith(".js") || id.endsWith(".mjs")));
-				if (hasGraphQLResolverFile) return `chunks/graphql/[name].mjs`;
-				if (typeof originalChunkFileNames === "function") return originalChunkFileNames(chunk);
-				return originalChunkFileNames || "chunks/_/[name].mjs";
-			};
+			types.tsConfig.include.push(relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-server.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "nitro-graphql-client.d.ts")), relativeWithDot(tsconfigDir, join(typesDir, "graphql.d.ts")));
 		});
 	}
 });

package/dist/internal/create-merged-schema.d.ts

@@ -0,0 +1,7 @@
+import * as graphql8 from "graphql";
+import * as graphql_yoga9 from "graphql-yoga";
+
+//#region src/internal/create-merged-schema.d.ts
+declare function createMergedSchema(): graphql_yoga9.GraphQLSchemaWithContext<graphql8.GraphQLResolveInfo & graphql_yoga9.YogaInitialContext>;
+//#endregion
+export { createMergedSchema };

package/dist/internal/create-merged-schema.js

@@ -0,0 +1,23 @@
+import { createSchema } from "graphql-yoga";
+import { mergeResolvers, mergeTypeDefs } from "@graphql-tools/merge";
+import { defs } from "#nitro-internal-virtual/server-defs";
+import { resolvers } from "#nitro-internal-virtual/server-resolvers";
+
+//#region src/internal/create-merged-schema.ts
+function createMergedSchema() {
+	try {
+		const mergedDefs = defs.map((schema) => schema.def).join("\n\n");
+		const typeDefs = mergeTypeDefs([mergedDefs]);
+		const mergedResolvers = mergeResolvers(resolvers.map((r) => r.resolver));
+		return createSchema({
+			typeDefs,
+			resolvers: mergedResolvers
+		});
+	} catch (error) {
+		console.error("Schema merge error:", error);
+		throw error;
+	}
+}
+
+//#endregion
+export { createMergedSchema };

package/dist/internal/index.d.ts

@@ -0,0 +1,2 @@
+import { createMergedSchema } from "./create-merged-schema.js";
+export { createMergedSchema };

package/dist/internal/index.js

@@ -0,0 +1,3 @@
+import { createMergedSchema } from "./create-merged-schema.js";
+
+export { createMergedSchema };

package/dist/node_modules/.pnpm/@graphql-codegen_add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/config.js

@@ -0,0 +1,9 @@
+//#region node_modules/.pnpm/@graphql-codegen+add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/config.js
+const VALID_PLACEMENTS = [
+	"prepend",
+	"content",
+	"append"
+];
+
+//#endregion
+export { VALID_PLACEMENTS };

package/dist/node_modules/.pnpm/@graphql-codegen_add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/index.js

@@ -0,0 +1,17 @@
+import { VALID_PLACEMENTS } from "./config.js";
+
+//#region node_modules/.pnpm/@graphql-codegen+add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/index.js
+const plugin = async (schema, documents, config) => {
+	const placement = config.placement || "prepend";
+	const { content } = config;
+	if (!VALID_PLACEMENTS.includes(placement)) throw Error(`Configuration provided for 'add' plugin is invalid: value of 'placement' field is not valid (valid values are: ${VALID_PLACEMENTS.join(", ")})`);
+	if (!content) throw Error(`Configuration provided for 'add' plugin is invalid: "content" is missing!`);
+	return {
+		content: null,
+		[placement]: Array.isArray(content) ? content : [content]
+	};
+};
+var esm_default = { plugin };
+
+//#endregion
+export { esm_default as default };

package/dist/node_modules/.pnpm/@graphql-codegen_import-types-preset@3.0.1_graphql@16.11.0/node_modules/@graphql-codegen/import-types-preset/esm/index.js

@@ -0,0 +1,38 @@
+import esm_default from "../../../../../@graphql-codegen_add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/index.js";
+import { isUsingTypes } from "../../../../../@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/helpers.js";
+import "../../../../../@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/index.js";
+
+//#region node_modules/.pnpm/@graphql-codegen+import-types-preset@3.0.1_graphql@16.11.0/node_modules/@graphql-codegen/import-types-preset/esm/index.js
+const preset = { buildGeneratesSection: (options) => {
+	if (!options.presetConfig.typesPath) throw new Error(`Preset "import-types" requires you to specify "typesPath" configuration and point it to your base types file (generated by "typescript" plugin)!`);
+	const importTypesNamespace = options.presetConfig.importTypesNamespace || "Types";
+	const pluginMap = {
+		...options.pluginMap,
+		add: esm_default
+	};
+	const plugins = [...options.plugins];
+	const config = {
+		...options.config,
+		namespacedImportName: importTypesNamespace,
+		importOperationTypesFrom: importTypesNamespace,
+		externalFragments: []
+	};
+	options.documents.map((documentFile) => {
+		if (isUsingTypes(documentFile.document, config.externalFragments.map((m) => m.name), options.schemaAst)) {
+			const importType = options.config.useTypeImports ? "import type" : "import";
+			plugins.unshift({ add: { content: `${importType} * as ${importTypesNamespace} from '${options.presetConfig.typesPath}';\n` } });
+		}
+	});
+	return [{
+		filename: options.baseOutputDir,
+		plugins,
+		pluginMap,
+		config,
+		schema: options.schema,
+		schemaAst: options.schemaAst,
+		documents: options.documents
+	}];
+} };
+
+//#endregion
+export { preset };

package/dist/node_modules/.pnpm/@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/federation.js

@@ -0,0 +1,22 @@
+import { __toESM } from "../../../../../../../_virtual/rolldown_runtime.js";
+import "./utils.js";
+import { require_merge } from "../../../../../lodash@4.17.21/node_modules/lodash/merge.js";
+import "./index.js";
+import "@graphql-tools/utils";
+import { isObjectType, parse } from "graphql";
+
+//#region node_modules/.pnpm/@graphql-codegen+plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/federation.js
+var import_merge = __toESM(require_merge(), 1);
+/**
+* Federation Spec
+*/
+const federationSpec = parse(`
+  scalar _FieldSet
+
+  directive @external on FIELD_DEFINITION
+  directive @requires(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @provides(fields: _FieldSet!) on FIELD_DEFINITION
+  directive @key(fields: _FieldSet!) on OBJECT | INTERFACE
+`);
+
+//#endregion

package/dist/node_modules/.pnpm/@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/getCachedDocumentNodeFromSchema.js

@@ -0,0 +1,6 @@
+import { getDocumentNodeFromSchema, memoize1 } from "@graphql-tools/utils";
+
+//#region node_modules/.pnpm/@graphql-codegen+plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/getCachedDocumentNodeFromSchema.js
+const getCachedDocumentNodeFromSchema = memoize1(getDocumentNodeFromSchema);
+
+//#endregion