nitro-graphql 1.2.3 → 1.3.0

package/dist/utils/directive-parser.js

@@ -0,0 +1,235 @@
+//#region src/utils/directive-parser.ts
+/**
+* Clean AST-based directive parser using oxc-parser
+*/
+var DirectiveParser = class {
+	oxc;
+	async init() {
+		if (!this.oxc) this.oxc = await import("oxc-parser");
+	}
+	/**
+	* Parse directives from a TypeScript/JavaScript file
+	*/
+	async parseDirectives(fileContent, filePath) {
+		await this.init();
+		try {
+			const result = this.oxc.parseSync(filePath, fileContent, {
+				lang: filePath.endsWith(".ts") ? "ts" : "js",
+				sourceType: "module",
+				astType: "ts"
+			});
+			if (result.errors.length > 0) {
+				console.warn(`Parse errors in ${filePath}:`, result.errors.map((e) => e.message));
+				return [];
+			}
+			return this.extractDirectiveDefinitions(result.program);
+		} catch (error) {
+			console.warn(`Failed to parse ${filePath} with oxc:`, error);
+			return [];
+		}
+	}
+	/**
+	* Extract directive definitions from AST
+	*/
+	extractDirectiveDefinitions(program) {
+		const directives = [];
+		this.traverse(program, (node) => {
+			if (this.isDefineDirectiveCall(node)) {
+				const directive = this.extractDirectiveFromCall(node);
+				if (directive) directives.push(directive);
+			}
+		});
+		return directives;
+	}
+	/**
+	* Traverse AST nodes recursively
+	*/
+	traverse(node, visitor) {
+		if (!node || typeof node !== "object") return;
+		visitor(node);
+		for (const key in node) {
+			const child = node[key];
+			if (Array.isArray(child)) child.forEach((item) => this.traverse(item, visitor));
+			else if (child && typeof child === "object") this.traverse(child, visitor);
+		}
+	}
+	/**
+	* Check if node is a defineDirective call
+	*/
+	isDefineDirectiveCall(node) {
+		return node.type === "CallExpression" && node.callee?.type === "Identifier" && node.callee.name === "defineDirective" && node.arguments?.length > 0;
+	}
+	/**
+	* Extract directive configuration from defineDirective call
+	*/
+	extractDirectiveFromCall(node) {
+		const arg = node.arguments[0];
+		if (arg?.type !== "ObjectExpression") return null;
+		return this.extractDirectiveFromObject(arg);
+	}
+	/**
+	* Extract directive properties from object expression
+	*/
+	extractDirectiveFromObject(objNode) {
+		let name = "";
+		let locations = [];
+		let args = {};
+		let description;
+		let isRepeatable;
+		for (const prop of objNode.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "name":
+					name = this.extractStringLiteral(prop.value) || "";
+					break;
+				case "locations":
+					locations = this.extractStringArray(prop.value);
+					break;
+				case "args":
+					args = this.extractArgsObject(prop.value);
+					break;
+				case "description":
+					description = this.extractStringLiteral(prop.value);
+					break;
+				case "isRepeatable":
+					isRepeatable = this.extractBooleanLiteral(prop.value);
+					break;
+			}
+		}
+		return name && locations.length > 0 ? {
+			name,
+			locations,
+			args,
+			description,
+			isRepeatable
+		} : null;
+	}
+	/**
+	* Extract string literal value
+	*/
+	extractStringLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "string") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract boolean literal value
+	*/
+	extractBooleanLiteral(node) {
+		if (node?.type === "Literal" && typeof node.value === "boolean") return node.value;
+		return void 0;
+	}
+	/**
+	* Extract array of strings
+	*/
+	extractStringArray(node) {
+		if (node?.type !== "ArrayExpression") return [];
+		return (node.elements || []).filter((el) => el?.type === "Literal" && typeof el.value === "string").map((el) => el.value);
+	}
+	/**
+	* Extract arguments object
+	*/
+	extractArgsObject(node) {
+		if (node?.type !== "ObjectExpression") return {};
+		const args = {};
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			const argName = prop.key.name;
+			const argConfig = this.extractArgConfig(prop.value);
+			if (argConfig) args[argName] = argConfig;
+		}
+		return args;
+	}
+	/**
+	* Extract argument configuration
+	*/
+	extractArgConfig(node) {
+		if (node?.type !== "ObjectExpression") return null;
+		let type = "String";
+		let defaultValue;
+		for (const prop of node.properties || []) {
+			if (prop.type !== "Property" || prop.key?.type !== "Identifier") continue;
+			switch (prop.key.name) {
+				case "type": {
+					const typeValue = this.extractStringLiteral(prop.value);
+					if (typeValue) type = typeValue;
+					break;
+				}
+				case "defaultValue":
+					defaultValue = this.extractLiteralValue(prop.value);
+					break;
+			}
+		}
+		return {
+			type,
+			...defaultValue !== void 0 && { defaultValue }
+		};
+	}
+	/**
+	* Extract literal value (string, number, boolean)
+	*/
+	extractLiteralValue(node) {
+		if (node?.type === "Literal") return node.value;
+		return void 0;
+	}
+};
+/**
+* Generate GraphQL directive schema from parsed directive
+*/
+function generateDirectiveSchema(directive) {
+	let args = "";
+	if (directive.args && Object.keys(directive.args).length > 0) {
+		const argDefs = Object.entries(directive.args).map(([name, arg]) => {
+			let defaultValue = "";
+			if (arg.defaultValue !== void 0) if (typeof arg.defaultValue === "string") defaultValue = ` = "${arg.defaultValue}"`;
+			else defaultValue = ` = ${arg.defaultValue}`;
+			return `${name}: ${arg.type}${defaultValue}`;
+		});
+		args = `(${argDefs.join(", ")})`;
+	}
+	const locations = directive.locations.join(" | ");
+	return `directive @${directive.name}${args} on ${locations}`;
+}
+/**
+* Generate directive schemas file from scanned directives
+*/
+async function generateDirectiveSchemas(nitro, directives) {
+	if (directives.length === 0) return;
+	const { existsSync, readFileSync, writeFileSync } = await import("node:fs");
+	const { readFile } = await import("node:fs/promises");
+	const { resolve } = await import("pathe");
+	const directiveSchemas = [];
+	const seenDirectives = /* @__PURE__ */ new Set();
+	const parser = new DirectiveParser();
+	for (const dir of directives) for (const _imp of dir.imports) {
+		const fileContent = await readFile(dir.specifier, "utf-8");
+		const directiveDefs = await parser.parseDirectives(fileContent, dir.specifier);
+		for (const def of directiveDefs) {
+			if (seenDirectives.has(def.name)) continue;
+			seenDirectives.add(def.name);
+			const schema = generateDirectiveSchema(def);
+			directiveSchemas.push(schema);
+		}
+	}
+	if (directiveSchemas.length > 0) {
+		const directivesPath = resolve(nitro.graphql.serverDir, "_directives.graphql");
+		const content = `# WARNING: This file is auto-generated by nitro-graphql
+# Do not modify this file directly. It will be overwritten.
+# To define custom directives, create .directive.ts files using defineDirective()
+
+${directiveSchemas.join("\n\n")}`;
+		let shouldWrite = true;
+		if (existsSync(directivesPath)) {
+			const existingContent = readFileSync(directivesPath, "utf-8");
+			shouldWrite = existingContent !== content;
+		}
+		if (shouldWrite) writeFileSync(directivesPath, content, "utf-8");
+		if (!nitro.scanSchemas.includes(directivesPath)) nitro.scanSchemas.push(directivesPath);
+	}
+}
+/**
+* Singleton instance for reuse
+*/
+const directiveParser = new DirectiveParser();
+
+//#endregion
+export { DirectiveParser, directiveParser, generateDirectiveSchema, generateDirectiveSchemas };

package/dist/utils/index.d.ts

@@ -1,4 +1,5 @@
 import { GenImport } from "../types/index.js";
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { Nitro } from "nitropack";
 
 //#region src/utils/index.d.ts
@@ -7,7 +8,7 @@ declare function getImportId(p: string, lazy?: boolean): string;
 declare function relativeWithDot(from: string, to: string): string;
 declare function scanGraphql(nitro: Nitro): Promise<string[]>;
 declare function scanResolvers(nitro: Nitro): Promise<GenImport[]>;
-declare function scanDirectives(nitro: Nitro): Promise<string[]>;
+declare function scanDirectives(nitro: Nitro): Promise<GenImport[]>;
 declare function scanTypeDefs(nitro: Nitro): Promise<string[]>;
 declare function scanSchemas(nitro: Nitro): Promise<string[]>;
 declare function scanDocs(nitro: Nitro): Promise<string[]>;
@@ -20,4 +21,4 @@ declare function scanExternalServiceDocs(nitro: Nitro, serviceName: string, patt
  */
 declare function validateExternalServices(services: any[]): string[];
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/index.js

@@ -1,3 +1,4 @@
+import { directiveParser, generateDirectiveSchema, generateDirectiveSchemas } from "./directive-parser.js";
 import { join, relative } from "pathe";
 import { readFile } from "node:fs/promises";
 import { hash } from "ohash";
@@ -56,6 +57,11 @@ async function scanResolvers(nitro) {
 						type: "subscription",
 						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
 					});
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
+						name: decl.id.name,
+						type: "directive",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
 				}
 			}
 		}
@@ -65,7 +71,28 @@ async function scanResolvers(nitro) {
 }
 async function scanDirectives(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.directive.{ts,js}");
-	return files.map((f) => f.fullPath);
+	const exportName = [];
+	for (const file of files) {
+		const fileContent = await readFile(file.fullPath, "utf-8");
+		const parsed = await parseAsync(file.fullPath, fileContent);
+		const exports = {
+			imports: [],
+			specifier: file.fullPath
+		};
+		for (const node of parsed.program.body) if (node.type === "ExportNamedDeclaration" && node.declaration && node.declaration.type === "VariableDeclaration") {
+			for (const decl of node.declaration.declarations) if (decl.type === "VariableDeclarator" && decl.init && decl.id.type === "Identifier") {
+				if (decl.init && decl.init.type === "CallExpression") {
+					if (decl.init.callee.type === "Identifier" && decl.init.callee.name === "defineDirective") exports.imports.push({
+						name: decl.id.name,
+						type: "directive",
+						as: `_${hash(decl.id.name + file.path).replace(/-/g, "").slice(0, 6)}`
+					});
+				}
+			}
+		}
+		if (exports.imports.length > 0) exportName.push(exports);
+	}
+	return exportName;
 }
 async function scanTypeDefs(nitro) {
 	const files = await scanFiles(nitro, "graphql", "**/*.typedef.{ts,js}");
@@ -77,7 +104,18 @@ async function scanSchemas(nitro) {
 }
 async function scanDocs(nitro) {
 	const files = await scanDir(nitro, nitro.options.rootDir, nitro.graphql.dir.client, "**/*.graphql");
-	return files.filter((f) => !f.path.startsWith("external/")).map((f) => f.fullPath);
+	const externalServices = nitro.options.graphql?.externalServices || [];
+	const externalPatterns = externalServices.flatMap((service) => service.documents || []);
+	return files.filter((f) => !f.path.startsWith("external/")).filter((f) => {
+		const relativePath = f.path;
+		for (const pattern of externalPatterns) {
+			const cleanPattern = pattern.replace(/^app\/graphql\//, "");
+			const patternDir = cleanPattern.split("/")[0];
+			const fileDir = relativePath.split("/")[0];
+			if (patternDir === fileDir) return false;
+		}
+		return true;
+	}).map((f) => f.fullPath);
 }
 /**
 * Scan documents for a specific external service
@@ -112,7 +150,7 @@ function validateExternalServices(services) {
 		if (!service.schema) errors.push(`${prefix}.schema is required`);
 		if (!service.endpoint || typeof service.endpoint !== "string") errors.push(`${prefix}.endpoint is required and must be a string`);
 		else try {
-			const url = new URL(service.endpoint);
+			new URL(service.endpoint);
 		} catch {
 			errors.push(`${prefix}.endpoint "${service.endpoint}" must be a valid URL`);
 		}
@@ -146,4 +184,4 @@ async function scanDir(nitro, dir, name, globPattern = GLOB_SCAN_PATTERN) {
 }
 
 //#endregion
-export { GLOB_SCAN_PATTERN, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };
+export { GLOB_SCAN_PATTERN, directiveParser, generateDirectiveSchema, generateDirectiveSchemas, getImportId, relativeWithDot, scanDirectives, scanDocs, scanExternalServiceDocs, scanGraphql, scanResolvers, scanSchemas, scanTypeDefs, validateExternalServices };

package/dist/utils/type-generation.js

@@ -2,8 +2,8 @@ import { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes
 import { generateTypes } from "./server-codegen.js";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import consola from "consola";
-import { dirname, join, resolve } from "pathe";
-import { buildASTSchema, buildSchema } from "graphql";
+import { basename, dirname, join, resolve } from "pathe";
+import { buildSchema, parse } from "graphql";
 import { loadFilesSync } from "@graphql-tools/load-files";
 import { mergeTypeDefs } from "@graphql-tools/merge";
 import { printSchemaWithDirectives } from "@graphql-tools/utils";
@@ -89,6 +89,98 @@ export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}Gra
 		writeFileSync(ofetchPath, ofetchContent, "utf-8");
 	}
 }
+/**
+* Check for duplicate type definitions using a simpler approach
+* Try to build each schema individually - if that succeeds but merging fails, we have duplicates
+* @returns true if validation passes, false if duplicates found
+*/
+function validateNoDuplicateTypes(schemas, schemaStrings) {
+	const individualSchemasByFile = /* @__PURE__ */ new Map();
+	schemaStrings.forEach((schemaContent, index) => {
+		const schemaPath = schemas[index];
+		const fileName = basename(schemaPath);
+		try {
+			parse(schemaContent);
+			individualSchemasByFile.set(fileName, schemaContent);
+		} catch (error) {
+			consola.warn(`Invalid GraphQL syntax in ${fileName}:`, error);
+			throw error;
+		}
+	});
+	try {
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: false,
+			commentDescriptions: true,
+			sort: true
+		});
+		mergeTypeDefs([schemaStrings.join("\n\n")], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
+		});
+	} catch (conflictError) {
+		if (conflictError?.message?.includes("already defined with a different type")) throw conflictError;
+	}
+	const typeNames = /* @__PURE__ */ new Set();
+	const duplicateTypes = [];
+	schemaStrings.forEach((schemaContent, index) => {
+		const fileName = basename(schemas[index]);
+		try {
+			const document = parse(schemaContent);
+			document.definitions.forEach((def) => {
+				if (def.kind === "ObjectTypeDefinition" || def.kind === "InterfaceTypeDefinition" || def.kind === "UnionTypeDefinition" || def.kind === "EnumTypeDefinition" || def.kind === "InputObjectTypeDefinition" || def.kind === "ScalarTypeDefinition") {
+					const typeName = def.name.value;
+					if ([
+						"String",
+						"Int",
+						"Float",
+						"Boolean",
+						"ID",
+						"DateTime",
+						"JSON"
+					].includes(typeName)) return;
+					if (typeNames.has(typeName)) {
+						const existing = duplicateTypes.find((d) => d.type === typeName);
+						if (existing) existing.files.push(fileName);
+						else {
+							const firstFile = schemas.find((_, i) => {
+								const content = schemaStrings[i];
+								if (!content) return false;
+								try {
+									const doc = parse(content);
+									return doc.definitions.some((d) => (d.kind === "ObjectTypeDefinition" || d.kind === "InterfaceTypeDefinition" || d.kind === "UnionTypeDefinition" || d.kind === "EnumTypeDefinition" || d.kind === "InputObjectTypeDefinition" || d.kind === "ScalarTypeDefinition") && d.name.value === typeName);
+								} catch {
+									return false;
+								}
+							});
+							duplicateTypes.push({
+								type: typeName,
+								files: [basename(firstFile || ""), fileName]
+							});
+						}
+					} else typeNames.add(typeName);
+				}
+			});
+		} catch {}
+	});
+	if (duplicateTypes.length > 0) {
+		let errorMessage = "⚠️  DUPLICATE TYPE DEFINITIONS DETECTED!\n\n";
+		duplicateTypes.forEach(({ type, files }) => {
+			errorMessage += `❌ Type "${type}" is defined in multiple files:\n`;
+			files.forEach((fileName) => {
+				const fullPath = schemas.find((path) => basename(path) === fileName) || fileName;
+				errorMessage += `   • ${fullPath}\n`;
+			});
+			errorMessage += "\n";
+		});
+		errorMessage += "💡 Each GraphQL type should only be defined once.\n";
+		errorMessage += "   Consider using \"extend type\" syntax instead of duplicate definitions.\n";
+		errorMessage += `\n🔍 Found ${duplicateTypes.length} duplicate type(s): ${duplicateTypes.map((d) => d.type).join(", ")}`;
+		consola.error(errorMessage);
+		return false;
+	}
+	return true;
+}
 async function serverTypeGeneration(app) {
 	try {
 		const schemas = app.scanSchemas || [];
@@ -97,11 +189,16 @@ async function serverTypeGeneration(app) {
 			return;
 		}
 		const loadSchemas = loadFilesSync(schemas);
-		const mergedSchemas = mergeTypeDefs(loadSchemas);
-		const schema = buildASTSchema(mergedSchemas, {
-			assumeValidSDL: true,
-			assumeValid: true
+		const schemaStrings = loadSchemas.map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
+		const isValid = validateNoDuplicateTypes(schemas, schemaStrings);
+		if (!isValid) return;
+		const mergedSchemasString = schemaStrings.join("\n\n");
+		const mergedSchemas = mergeTypeDefs([mergedSchemasString], {
+			throwOnConflict: true,
+			commentDescriptions: true,
+			sort: true
 		});
+		const schema = buildSchema(mergedSchemas);
 		const data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql?.codegen?.server ?? {});
 		const printSchema = printSchemaWithDirectives(schema);
 		const schemaPath = resolve(app.graphql.buildDir, "schema.graphql");

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "nitro-graphql",
   "type": "module",
-  "version": "1.2.3",
+  "version": "1.3.0",
   "description": "GraphQL integration for Nitro",
   "license": "MIT",
   "sideEffects": false,
@@ -55,25 +55,38 @@
     "dist"
   ],
   "peerDependencies": {
+    "@apollo/server": "^5.0.0",
+    "@apollo/utils.withrequired": "^3.0.0",
+    "@as-integrations/h3": "^2.0.0",
     "graphql": "^16.11.0",
     "h3": "^1.15.3",
     "nitropack": "^2.11.13"
   },
+  "peerDependenciesMeta": {
+    "@apollo/server": {
+      "optional": true
+    },
+    "@apollo/utils.withrequired": {
+      "optional": true
+    },
+    "@as-integrations/h3": {
+      "optional": true
+    }
+  },
   "dependencies": {
-    "@apollo/utils.withrequired": "^3.0.0",
-    "@as-integrations/h3": "^2.0.0",
     "@graphql-codegen/core": "^4.0.2",
+    "@graphql-codegen/import-types-preset": "^3.0.1",
     "@graphql-codegen/typescript": "^4.1.6",
     "@graphql-codegen/typescript-generic-sdk": "^4.0.2",
     "@graphql-codegen/typescript-operations": "^4.6.1",
     "@graphql-codegen/typescript-resolvers": "^4.5.1",
-    "@graphql-tools/graphql-file-loader": "^8.0.21",
-    "@graphql-tools/load": "^8.1.1",
+    "@graphql-tools/graphql-file-loader": "^8.1.0",
+    "@graphql-tools/load": "^8.1.2",
     "@graphql-tools/load-files": "^7.0.1",
-    "@graphql-tools/merge": "^9.1.0",
-    "@graphql-tools/schema": "^10.0.24",
+    "@graphql-tools/merge": "^9.1.1",
+    "@graphql-tools/schema": "^10.0.25",
     "@graphql-tools/url-loader": "^8.0.33",
-    "@graphql-tools/utils": "^10.9.0",
+    "@graphql-tools/utils": "^10.9.1",
     "chokidar": "^4.0.3",
     "consola": "^3.4.2",
     "defu": "^6.1.4",
@@ -81,27 +94,25 @@
     "graphql-scalars": "^1.24.2",
     "knitwork": "^1.2.0",
     "ohash": "^2.0.11",
-    "oxc-parser": "^0.77.2",
+    "oxc-parser": "^0.82.3",
     "pathe": "^2.0.3",
     "tinyglobby": "^0.2.14"
   },
   "devDependencies": {
-    "@antfu/eslint-config": "^4.17.0",
-    "@apollo/server": "^5.0.0",
-    "@graphql-codegen/import-types-preset": "^3.0.1",
+    "@antfu/eslint-config": "^5.2.1",
     "@nuxt/kit": "^4.0.3",
     "@nuxt/schema": "^4.0.3",
-    "@types/node": "^20.19.9",
-    "bumpp": "^10.2.0",
+    "@types/node": "^22.18.0",
+    "bumpp": "^10.2.3",
     "changelogen": "^0.6.2",
     "crossws": "0.3.5",
-    "eslint": "^9.31.0",
+    "eslint": "^9.34.0",
     "graphql": "^16.11.0",
     "graphql-yoga": "^5.15.1",
     "h3": "1.15.3",
-    "nitropack": "^2.12.3",
-    "tsdown": "^0.12.9",
-    "typescript": "^5.8.3"
+    "nitropack": "^2.12.4",
+    "tsdown": "^0.14.2",
+    "typescript": "^5.9.2"
   },
   "resolutions": {
     "nitro-graphql": "link:."

package/dist/_virtual/rolldown_runtime.js

@@ -1,37 +0,0 @@
-//#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/node_modules/.pnpm/@graphql-codegen_add@3.2.3_graphql@16.11.0/node_modules/@graphql-codegen/add/esm/config.js

@@ -1,9 +0,0 @@
-//#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

@@ -1,17 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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 };