nitro-graphql 0.0.4 → 0.0.6

package/README.md

@@ -46,21 +46,6 @@ export default defineNitroConfig({
     endpoint: '/api/graphql', // default
     playground: true, // default (Apollo Sandbox)
     cors: false, // default
-    cacheHeaders: {
-      enabled: true, // default
-      maxAge: 604800, // default (1 week)
-    },
-    client: {
-      enabled: false, // default
-      outputPath: undefined, // Will default to .nitro/types/graphql-client.generated.ts
-      watchPatterns: undefined, // Will default to src/**/*.{graphql,gql} excluding server/graphql
-      config: {
-        documentMode: 'string',
-        emitLegacyCommonJSImports: false,
-        useTypeImports: true,
-        enumsAsTypes: true,
-      }
-    }
   }
 })
 ```
@@ -173,7 +158,7 @@ The module automatically generates TypeScript types from your GraphQL schema:
 These types are automatically available in your resolvers:
 
 ```ts
-import type { QueryResolvers } from '#build/graphql-types.generated'
+import type { QueryResolvers } from '#graphql/server'
 // server/graphql/users/user-queries.ts
 import { defineResolver } from 'nitro-graphql'
 
@@ -258,12 +243,6 @@ interface NitroGraphQLYogaOptions {
     methods?: string[]
   }
 
-  // Cache headers configuration
-  cacheHeaders?: {
-    enabled?: boolean // default: true
-    maxAge?: number // default: 604800 (1 week)
-  }
-
   // Client type generation
   client?: {
     enabled?: boolean // default: false
@@ -362,14 +341,6 @@ Enable client type generation for your frontend queries:
 // nitro.config.ts
 export default defineNitroConfig({
   graphqlYoga: {
-    client: {
-      enabled: true,
-      watchPatterns: [
-        'client/**/*.graphql',
-        'pages/**/*.vue',
-        'components/**/*.vue'
-      ]
-    }
   }
 })
 ```

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/ecosystem/nuxt.d.ts

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

package/dist/ecosystem/nuxt.js

@@ -0,0 +1,30 @@
+import { join, resolve } from "pathe";
+import { 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" }
+	},
+	setup: async (_options, nuxt) => {
+		nuxt.hooks.hook("prepare:types", (options) => {
+			options.references.push({ path: "types/nitro-graphql-client.d.ts" });
+			options.tsConfig ??= {};
+			options.tsConfig.compilerOptions ??= {};
+			options.tsConfig.compilerOptions.paths ??= {};
+			options.tsConfig.compilerOptions.paths["#graphql/client"] = ["./types/nitro-graphql-client.d.ts"];
+			options.tsConfig.include = options.tsConfig.include || [];
+			options.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");
+		nuxt.hook("imports:dirs", (dirs) => {
+			dirs.push(resolve(nuxt.options.srcDir, "graphql"));
+		});
+	}
+});
+
+//#endregion
+export { nuxt_default as default };

package/dist/graphql/index.d.ts

@@ -0,0 +1,5 @@
+//#region src/graphql/index.d.ts
+interface StandardSchemaV1 extends Record<string, any> {}
+interface ResolversTypes extends Record<string, any> {}
+//#endregion
+export { ResolversTypes, StandardSchemaV1 };

package/dist/graphql/server.d.ts

@@ -0,0 +1,5 @@
+//#region src/graphql/server.d.ts
+interface StandardSchemaV1 extends Record<string, any> {}
+interface ResolversTypes extends Record<string, any> {}
+//#endregion
+export { ResolversTypes, StandardSchemaV1 };

package/dist/index.d.ts

@@ -1,6 +1,12 @@
-import * as nitropack0 from "nitropack";
+import { StandardSchemaV1 } from "./types/standard-schema.js";
+import { CodegenClientConfig, CodegenServerConfig, GenImport, NitroGraphQLOptions } from "./types/index.js";
+import { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType } from "./utils/define.js";
+import * as nitropack5 from "nitropack";
 
 //#region src/index.d.ts
-declare const _default: nitropack0.NitroModule;
+interface Resolvers extends Record<string, any> {}
+interface CustomSchema extends Record<string, any> {}
+type GraphQLFramework = 'graphql-yoga';
+declare const _default: nitropack5.NitroModule;
 //#endregion
-export { _default as default };
+export { CodegenClientConfig, CodegenServerConfig, CustomSchema, GenImport, GraphQLFramework, NitroGraphQLOptions, Resolvers, StandardSchemaV1, _default as default, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

package/dist/index.js

@@ -1,162 +1,152 @@
-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 { defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType } from "./utils/define.js";
+import { writeFileSync } from "node:fs";
+import { fileURLToPath } from "node:url";
+import { watch } from "chokidar";
+import defu from "defu";
 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;
+		nitro.graphql ||= {
+			buildDir: "",
+			watchDirs: [],
+			clientDir: "",
+			serverDir: resolve(nitro.options.srcDir, "graphql")
+		};
+		nitro.hooks.hook("rollup:before", (nitro$1, rollupConfig$1) => {
+			rollupConfig$1.external = rollupConfig$1.external || [];
+			const codegenExternals = ["oxc-parser", "@oxc-parser"];
+			if (Array.isArray(rollupConfig$1.external)) rollupConfig$1.external.push(...codegenExternals);
+			else if (typeof rollupConfig$1.external === "function") {
+				const originalExternal = rollupConfig$1.external;
+				rollupConfig$1.external = (id, parent, isResolved) => {
+					if (codegenExternals.some((external) => id.includes(external))) return true;
+					return originalExternal(id, parent, isResolved);
 				};
 			}
-		}
-		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.runtimeConfig.graphql = defu(nitro.options.runtimeConfig.graphql || {}, {
+			endpoint: {
+				graphql: "/api/graphql",
+				healthCheck: "/api/graphql/health"
 			},
-			...nitro.options.graphqlYoga,
-			...nitro.options.runtimeConfig?.graphqlYoga
-		};
-		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);
+			playground: true
+		});
+		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:
 		}
-		nitro.options.handlers.push({
-			route: endpoint,
-			handler: "#nitro-graphql/handler",
-			method: "get"
+		const watcher = 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);
 		});
-		nitro.options.handlers.push({
-			route: endpoint,
-			handler: "#nitro-graphql/handler",
-			method: "post"
+		nitro.hooks.hook("close", () => {
+			watcher.close();
 		});
-		nitro.options.handlers.push({
-			route: endpoint,
-			handler: "#nitro-graphql/handler",
-			method: "options"
+		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 runtime = fileURLToPath(new URL("routes", import.meta.url));
+		const methods = [
+			"get",
+			"post",
+			"options"
+		];
+		if (nitro.options.graphql?.framework === "graphql-yoga") for (const method of methods) nitro.options.handlers.push({
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+			handler: join(runtime, "graphql-yoga"),
+			method
+		});
+		if (nitro.options.graphql?.framework === "apollo-server") for (const method of methods) nitro.options.handlers.push({
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.graphql || "/api/graphql",
+			handler: join(runtime, "apollo-server"),
+			method
 		});
 		nitro.options.handlers.push({
-			route: `${endpoint}/health`,
-			handler: "#nitro-graphql/health",
+			route: nitro.options.runtimeConfig.graphql?.endpoint?.healthCheck || "/api/graphql/health",
+			handler: join(runtime, "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"]
+			from: "nitro-graphql/utils/define",
+			imports: [
+				"defineResolver",
+				"defineMutation",
+				"defineQuery",
+				"defineSubscription",
+				"defineType",
+				"defineGraphQLConfig",
+				"defineSchema"
+			]
 		});
-		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, SchemaType } from './nitro-graphql-server.d.ts'
+
+declare module 'nitro-graphql' {
+  interface Resolvers extends Test {}
+
+  interface CustomSchema extends SchemaType {}
+
+  type GraphQLFramework = '${nitro.options.graphql?.framework || "graphql-yoga"}'
+}
+`;
+		writeFileSync(join(typesDir, "graphql.d.ts"), graphqlDtsContent);
+		nitro.options.typescript.strict = true;
 		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")));
 		});
 	}
 });
 
 //#endregion
-export { src_default as default };
+export { src_default as default, defineGraphQLConfig, defineMutation, defineQuery, defineResolver, defineSchema, defineSubscription, defineType };

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 { isObjectType, parse } from "graphql";
+import "@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/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

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

@@ -0,0 +1,79 @@
+import { getBaseType } from "./utils.js";
+import { Kind, isListType, isNonNullType, isObjectType, visit } from "graphql";
+
+//#region node_modules/.pnpm/@graphql-codegen+plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/helpers.js
+function hasNullableTypeRecursively(type) {
+	if (!isNonNullType(type)) return true;
+	if (isListType(type) || isNonNullType(type)) return hasNullableTypeRecursively(type.ofType);
+	return false;
+}
+function isUsingTypes(document, externalFragments, schema) {
+	let foundFields = 0;
+	const typesStack = [];
+	visit(document, {
+		SelectionSet: {
+			enter(node, key, parent, anscestors) {
+				const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === "FragmentDefinition" && externalFragments.includes(f.name.value));
+				if (insideIgnoredFragment) return;
+				const selections = node.selections || [];
+				if (schema && selections.length > 0) {
+					const nextTypeName = (() => {
+						if (parent.kind === Kind.FRAGMENT_DEFINITION) return parent.typeCondition.name.value;
+						if (parent.kind === Kind.FIELD) {
+							const lastType = typesStack[typesStack.length - 1];
+							if (!lastType) throw new Error(`Unable to find parent type! Please make sure you operation passes validation`);
+							const field = lastType.getFields()[parent.name.value];
+							if (!field) throw new Error(`Unable to find field "${parent.name.value}" on type "${lastType}"!`);
+							return getBaseType(field.type).name;
+						}
+						if (parent.kind === Kind.OPERATION_DEFINITION) {
+							if (parent.operation === "query") return schema.getQueryType().name;
+							if (parent.operation === "mutation") return schema.getMutationType().name;
+							if (parent.operation === "subscription") return schema.getSubscriptionType().name;
+						} else if (parent.kind === Kind.INLINE_FRAGMENT) {
+							if (parent.typeCondition) return parent.typeCondition.name.value;
+							return typesStack[typesStack.length - 1].name;
+						}
+						return null;
+					})();
+					typesStack.push(schema.getType(nextTypeName));
+				}
+			},
+			leave(node) {
+				const selections = node.selections || [];
+				if (schema && selections.length > 0) typesStack.pop();
+			}
+		},
+		Field: { enter: (node, key, parent, path, anscestors) => {
+			if (node.name.value.startsWith("__")) return;
+			const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === "FragmentDefinition" && externalFragments.includes(f.name.value));
+			if (insideIgnoredFragment) return;
+			const selections = node.selectionSet ? node.selectionSet.selections || [] : [];
+			const relevantFragmentSpreads = selections.filter((s) => s.kind === Kind.FRAGMENT_SPREAD && !externalFragments.includes(s.name.value));
+			if (selections.length === 0 || relevantFragmentSpreads.length > 0) foundFields++;
+			if (schema) {
+				const lastType = typesStack[typesStack.length - 1];
+				if (lastType && isObjectType(lastType)) {
+					const field = lastType.getFields()[node.name.value];
+					if (!field) throw new Error(`Unable to find field "${node.name.value}" on type "${lastType}"!`);
+					const currentType = field.type;
+					if (hasNullableTypeRecursively(currentType)) foundFields++;
+				}
+			}
+		} },
+		VariableDefinition: { enter: (node, key, parent, path, anscestors) => {
+			const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === "FragmentDefinition" && externalFragments.includes(f.name.value));
+			if (insideIgnoredFragment) return;
+			foundFields++;
+		} },
+		InputValueDefinition: { enter: (node, key, parent, path, anscestors) => {
+			const insideIgnoredFragment = anscestors.find((f) => f.kind && f.kind === "FragmentDefinition" && externalFragments.includes(f.name.value));
+			if (insideIgnoredFragment) return;
+			foundFields++;
+		} }
+	});
+	return foundFields > 0;
+}
+
+//#endregion
+export { hasNullableTypeRecursively, isUsingTypes };

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

@@ -0,0 +1,6 @@
+import "./resolve-external-module-and-fn.js";
+import { getBaseType, isWrapperType } from "./utils.js";
+import { hasNullableTypeRecursively, isUsingTypes } from "./helpers.js";
+import "./federation.js";
+import "./getCachedDocumentNodeFromSchema.js";
+import "./oldVisit.js";

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

@@ -0,0 +1 @@
+import { visit } from "graphql";

package/dist/node_modules/.pnpm/@graphql-codegen_plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/resolve-external-module-and-fn.js

@@ -0,0 +1,7 @@
+import { __toESM } from "../../../../../../../_virtual/rolldown_runtime.js";
+import { require_dist } from "../../../../../change-case-all@1.0.15/node_modules/change-case-all/dist/index.js";
+
+//#region node_modules/.pnpm/@graphql-codegen+plugin-helpers@3.1.2_graphql@16.11.0/node_modules/@graphql-codegen/plugin-helpers/esm/resolve-external-module-and-fn.js
+var import_dist = __toESM(require_dist(), 1);
+
+//#endregion