nitro-graphql 2.0.0-beta.7 → 2.0.0-beta.72

package/dist/utils/server-codegen.js

@@ -1,136 +0,0 @@
-import consola from "consola";
-import { defu as defu$1 } from "defu";
-import { parse } from "graphql";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-import { codegen } from "@graphql-codegen/core";
-import * as typescriptPlugin from "@graphql-codegen/typescript";
-import { CurrencyResolver, DateTimeISOResolver, DateTimeResolver, JSONObjectResolver, JSONResolver, NonEmptyStringResolver, UUIDResolver } from "graphql-scalars";
-import * as typescriptResolversPlugin from "@graphql-codegen/typescript-resolvers";
-
-//#region src/utils/server-codegen.ts
-function pluginContent(_schema, _documents, _config, _info) {
-	return {
-		prepend: [
-			"// THIS FILE IS GENERATED, DO NOT EDIT!",
-			"/* eslint-disable eslint-comments/no-unlimited-disable */",
-			"/* tslint:disable */",
-			"/* eslint-disable */",
-			"/* prettier-ignore */"
-		],
-		content: ""
-	};
-}
-async function generateTypes(selectFremework, schema, config = {}, outputPath) {
-	const mergedConfig = defu$1({
-		scalars: {
-			DateTime: DateTimeResolver.extensions.codegenScalarType,
-			DateTimeISO: DateTimeISOResolver.extensions.codegenScalarType,
-			UUID: UUIDResolver.extensions.codegenScalarType,
-			JSON: JSONResolver.extensions.codegenScalarType,
-			JSONObject: JSONObjectResolver.extensions.codegenScalarType,
-			NonEmptyString: NonEmptyStringResolver.extensions.codegenScalarType,
-			Currency: CurrencyResolver.extensions.codegenScalarType,
-			File: {
-				input: "File",
-				output: "File"
-			}
-		},
-		defaultScalarType: "unknown",
-		defaultMapper: `ResolverReturnType<{T}>`,
-		contextType: "h3#H3Event",
-		maybeValue: "T | null | undefined",
-		inputMaybeValue: "T | undefined",
-		declarationKind: "interface",
-		enumsAsTypes: true,
-		...config.federation?.enabled && { federation: true }
-	}, config.codegen?.server);
-	return await codegen({
-		filename: outputPath || "types.generated.ts",
-		schema: parse(printSchemaWithDirectives(schema)),
-		documents: [],
-		config: mergedConfig,
-		plugins: [
-			{ imports: {} },
-			{ pluginContent: {} },
-			{ typescript: {} },
-			{ typescriptResolvers: {} }
-		],
-		pluginMap: {
-			pluginContent: { plugin: pluginContent },
-			imports: { plugin: () => {
-				return {
-					prepend: [
-						`import schemas from '#graphql/schema'`,
-						`import type { StandardSchemaV1 } from 'nitro-graphql'`,
-						`
-export interface NPMConfig {
-  framework: '${selectFremework || "graphql-yoga"}';
-}
-
-export type SchemaType = Partial<Record<Partial<keyof ResolversTypes>, StandardSchemaV1>>
-
-// Check if schemas is empty object, return never if so
-type SafeSchemaKeys<T> = T extends Record<PropertyKey, never> 
-  ? never 
-  : keyof T extends string | number | symbol
-    ? keyof T extends never 
-      ? never 
-      : keyof T
-    : never;
-    
-
-type SchemaKeys = SafeSchemaKeys<typeof schemas>;
-
-type InferInput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferInput<T> : unknown;
-type InferOutput<T> = T extends StandardSchemaV1 ? StandardSchemaV1.InferOutput<T> : unknown;
-
-type InferInputFromSchema<T extends SchemaKeys> = InferInput<(typeof schemas)[T]>;
-type InferOutputFromSchema<T extends SchemaKeys> = InferOutput<(typeof schemas)[T]>;
-
-type Primitive =
-| null
-| undefined
-| string
-| number
-| boolean
-| symbol
-| bigint;
-
-type BuiltIns = Primitive | void | Date | RegExp;
-
-
-type ResolverReturnType<T> = T extends BuiltIns
-? T
-: T extends (...args: any[]) => unknown
-? T | undefined
-: T extends object
-? T extends Array<infer ItemType> // Test for arrays/tuples, per https://github.com/microsoft/TypeScript/issues/35156
-  ? ItemType[] extends T // Test for arrays (non-tuples) specifically
-    ? Array<ResolverReturnType<ItemType>>
-    : ResolverReturnTypeObject<T> // Tuples behave properly
-  : ResolverReturnTypeObject<T>
-: unknown;
-
-type ResolverReturnTypeObject<T extends object> =
-  T extends { __typename?: infer TTypename }
-    ? TTypename extends SchemaKeys
-      ? InferOutputFromSchema<TTypename>
-      : { [K in keyof T]: ResolverReturnType<T[K]> }
-    : { [K in keyof T]: ResolverReturnType<T[K]> };
-`,
-						""
-					],
-					content: ""
-				};
-			} },
-			typescript: typescriptPlugin,
-			typescriptResolvers: typescriptResolversPlugin
-		}
-	}).catch((e) => {
-		consola.withTag("graphql").error("Error generating types:", e);
-		return "";
-	});
-}
-
-//#endregion
-export { generateTypes };

package/dist/utils/type-generation.d.ts

@@ -1,7 +0,0 @@
-import { Nitro } from "nitro/types";
-
-//#region src/utils/type-generation.d.ts
-declare function serverTypeGeneration(app: Nitro): Promise<void>;
-declare function clientTypeGeneration(nitro: Nitro): Promise<void>;
-//#endregion
-export { clientTypeGeneration, serverTypeGeneration };

package/dist/utils/type-generation.js

@@ -1,360 +0,0 @@
-import { downloadAndSaveSchema, generateClientTypes, generateExternalClientTypes, loadExternalSchema, loadGraphQLDocuments } from "./client-codegen.js";
-import { writeFileIfNotExists } from "./file-generator.js";
-import { getClientUtilsConfig, getDefaultPaths, getSdkConfig, getTypesConfig, resolveFilePath, shouldGenerateClientUtils, shouldGenerateTypes } from "./path-resolver.js";
-import { generateTypes } from "./server-codegen.js";
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
-import consola from "consola";
-import { basename, dirname, join, resolve } from "pathe";
-import { buildSchema, parse } from "graphql";
-import { buildSubgraphSchema } from "@apollo/subgraph";
-import { loadFilesSync } from "@graphql-tools/load-files";
-import { mergeTypeDefs } from "@graphql-tools/merge";
-import { printSchemaWithDirectives } from "@graphql-tools/utils";
-
-//#region src/utils/type-generation.ts
-function generateGraphQLIndexFile(nitro, clientDir, externalServices = []) {
-	if (!shouldGenerateClientUtils(nitro)) return;
-	const placeholders = getDefaultPaths(nitro);
-	const clientUtilsConfig = getClientUtilsConfig(nitro);
-	const indexPath = resolveFilePath(clientUtilsConfig.index, clientUtilsConfig.enabled, true, "{clientGraphql}/index.ts", placeholders);
-	if (!indexPath) return;
-	if (!existsSync(indexPath)) {
-		let indexContent = `// This file is auto-generated once by nitro-graphql for quick start
-// You can modify this file according to your needs
-//
-// Export your main GraphQL service (auto-generated)
-export * from './default/ofetch'
-
-// Export external GraphQL services (auto-generated for existing services)
-// When you add new external services, don't forget to add their exports here:
-// export * from './yourServiceName/ofetch'
-`;
-		for (const service of externalServices) indexContent += `export * from './${service.name}/ofetch'\n`;
-		writeFileIfNotExists(indexPath, indexContent, "client index.ts");
-	}
-}
-function generateNuxtOfetchClient(nitro, clientDir, serviceName = "default") {
-	if (!shouldGenerateClientUtils(nitro)) return;
-	const placeholders = {
-		...getDefaultPaths(nitro),
-		serviceName
-	};
-	const clientUtilsConfig = getClientUtilsConfig(nitro);
-	const ofetchPath = resolveFilePath(clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
-	if (!ofetchPath) return;
-	const serviceDir = dirname(ofetchPath);
-	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
-	if (existsSync(ofetchPath)) return;
-	writeFileIfNotExists(ofetchPath, `// This file is auto-generated once by nitro-graphql for quick start
-// You can modify this file according to your needs
-import type { Requester } from './sdk'
-import { getSdk } from './sdk'
-
-export function createGraphQLClient(endpoint: string): Requester {
-  return async <R>(doc: string, vars?: any): Promise<R> => {
-    const headers = import.meta.server ? useRequestHeaders() : undefined
-
-    const result = await $fetch(endpoint, {
-      method: 'POST',
-      body: { query: doc, variables: vars },
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers,
-      },
-    })
-
-    return result as R
-  }
-}
-
-export const $sdk = getSdk(createGraphQLClient('/api/graphql'))`, `${serviceName} ofetch.ts`);
-}
-function generateExternalOfetchClient(nitro, service, endpoint) {
-	if (!shouldGenerateClientUtils(nitro)) return;
-	const serviceName = service.name;
-	const placeholders = {
-		...getDefaultPaths(nitro),
-		serviceName
-	};
-	const clientUtilsConfig = getClientUtilsConfig(nitro);
-	const ofetchPath = resolveFilePath(service.paths?.ofetch ?? clientUtilsConfig.ofetch, clientUtilsConfig.enabled, true, "{clientGraphql}/{serviceName}/ofetch.ts", placeholders);
-	if (!ofetchPath) return;
-	const serviceDir = dirname(ofetchPath);
-	if (!existsSync(serviceDir)) mkdirSync(serviceDir, { recursive: true });
-	if (!existsSync(ofetchPath)) {
-		const capitalizedServiceName = serviceName.charAt(0).toUpperCase() + serviceName.slice(1);
-		writeFileIfNotExists(ofetchPath, `// This file is auto-generated once by nitro-graphql for quick start
-// You can modify this file according to your needs
-import type { Sdk, Requester } from './sdk'
-import { getSdk } from './sdk'
-
-export function create${capitalizedServiceName}GraphQLClient(endpoint: string = '${endpoint}'): Requester {
-  return async <R>(doc: string, vars?: any): Promise<R> => {
-    const headers = import.meta.server ? useRequestHeaders() : undefined
-
-    const result = await $fetch(endpoint, {
-      method: 'POST',
-      body: { query: doc, variables: vars },
-      headers: {
-        'Content-Type': 'application/json',
-        ...headers,
-      },
-    })
-
-    return result as R
-  }
-}
-
-export const $${serviceName}Sdk: Sdk = getSdk(create${capitalizedServiceName}GraphQLClient())`, `${serviceName} external ofetch.ts`);
-	}
-}
-/**
-* 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 {
-			parse(schemaContent).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 {
-									return parse(content).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 {
-		if (!shouldGenerateTypes(app)) {
-			consola.debug("[nitro-graphql] Server type generation is disabled");
-			return;
-		}
-		const schemas = app.scanSchemas || [];
-		if (!schemas.length) {
-			consola.info("No GraphQL definitions found for server type generation.");
-			return;
-		}
-		const schemaStrings = loadFilesSync(schemas).map((schema$1) => typeof schema$1 === "string" ? schema$1 : schema$1.loc?.source?.body || "").filter(Boolean);
-		if (!validateNoDuplicateTypes(schemas, schemaStrings)) return;
-		const federationEnabled = app.options.graphql?.federation?.enabled === true;
-		const mergedSchemas = mergeTypeDefs([schemaStrings.join("\n\n")], {
-			throwOnConflict: true,
-			commentDescriptions: true,
-			sort: true
-		});
-		const schema = federationEnabled ? buildSubgraphSchema([{ typeDefs: parse(mergedSchemas) }]) : buildSchema(mergedSchemas);
-		const data = await generateTypes(app.options.graphql?.framework || "graphql-yoga", schema, app.options.graphql ?? {});
-		const printSchema = printSchemaWithDirectives(schema);
-		const schemaPath = resolve(app.graphql.buildDir, "schema.graphql");
-		mkdirSync(dirname(schemaPath), { recursive: true });
-		writeFileSync(schemaPath, printSchema, "utf-8");
-		const placeholders = getDefaultPaths(app);
-		const typesConfig = getTypesConfig(app);
-		const serverTypesPath = resolveFilePath(typesConfig.server, typesConfig.enabled, true, "{typesDir}/nitro-graphql-server.d.ts", placeholders);
-		if (serverTypesPath) {
-			mkdirSync(dirname(serverTypesPath), { recursive: true });
-			writeFileSync(serverTypesPath, data, "utf-8");
-			consola.success(`[nitro-graphql] Generated server types at: ${serverTypesPath}`);
-		}
-	} catch (error) {
-		consola.error("Server schema generation error:", error);
-	}
-}
-async function clientTypeGeneration(nitro) {
-	try {
-		if (nitro.scanSchemas && nitro.scanSchemas.length > 0) await generateMainClientTypes(nitro);
-		if (nitro.options.graphql?.externalServices?.length) await generateExternalServicesTypes(nitro);
-	} catch (error) {
-		consola.error("Client schema generation error:", error);
-	}
-}
-/**
-* Check for old structure files and warn user about manual migration
-*/
-function checkOldStructure(clientDir) {
-	const oldOfetchPath = resolve(clientDir, "ofetch.ts");
-	const oldSdkPath = resolve(clientDir, "sdk.ts");
-	if (existsSync(oldOfetchPath) || existsSync(oldSdkPath)) {
-		const foundFiles = [];
-		if (existsSync(oldOfetchPath)) foundFiles.push("app/graphql/ofetch.ts");
-		if (existsSync(oldSdkPath)) foundFiles.push("app/graphql/sdk.ts");
-		consola.error(`⚠️  OLD GRAPHQL STRUCTURE DETECTED!
-
-📁 Found old files in app/graphql/ directory that need to be moved:
-   • ${foundFiles.join("\n   • ")}
-
-🔄 Please manually move these files to the new structure:
-   • app/graphql/ofetch.ts → app/graphql/default/ofetch.ts
-   • app/graphql/sdk.ts → app/graphql/default/sdk.ts
-
-📝 Also update your app/graphql/index.ts to include:
-   export * from './default/ofetch'
-
-💡 After moving, update your imports to use:
-   import { $sdk } from "#graphql/client"
-
-🚫 The old files will cause import conflicts until moved!`);
-	}
-}
-async function generateMainClientTypes(nitro) {
-	checkOldStructure(nitro.graphql.clientDir);
-	const docs = nitro.scanDocuments;
-	const loadDocs = await loadGraphQLDocuments(docs);
-	const schemaFilePath = join(nitro.graphql.buildDir, "schema.graphql");
-	if (!existsSync(schemaFilePath)) {
-		consola.info("Schema file not ready yet for client type generation. Server types need to be generated first.");
-		return;
-	}
-	const graphqlString = readFileSync(schemaFilePath, "utf-8");
-	const types = await generateClientTypes(nitro.options.graphql?.federation?.enabled === true ? buildSubgraphSchema([{ typeDefs: parse(graphqlString) }]) : buildSchema(graphqlString), loadDocs, nitro.options.graphql?.codegen?.client ?? {}, nitro.options.graphql?.codegen?.clientSDK ?? {});
-	if (types === false) return;
-	const placeholders = getDefaultPaths(nitro);
-	const typesConfig = getTypesConfig(nitro);
-	const sdkConfig = getSdkConfig(nitro);
-	const clientTypesPath = resolveFilePath(typesConfig.client, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client.d.ts", placeholders);
-	if (clientTypesPath) {
-		mkdirSync(dirname(clientTypesPath), { recursive: true });
-		writeFileSync(clientTypesPath, types.types, "utf-8");
-		consola.success(`[nitro-graphql] Generated client types at: ${clientTypesPath}`);
-	}
-	const sdkPath = resolveFilePath(sdkConfig.main, sdkConfig.enabled, true, "{clientGraphql}/default/sdk.ts", placeholders);
-	if (sdkPath) {
-		mkdirSync(dirname(sdkPath), { recursive: true });
-		writeFileSync(sdkPath, types.sdk, "utf-8");
-		consola.success(`[nitro-graphql] Generated SDK at: ${sdkPath}`);
-	}
-	if (nitro.options.framework?.name === "nuxt") {
-		generateNuxtOfetchClient(nitro, nitro.graphql.clientDir, "default");
-		const externalServices = nitro.options.graphql?.externalServices || [];
-		generateGraphQLIndexFile(nitro, nitro.graphql.clientDir, externalServices);
-	}
-}
-async function generateExternalServicesTypes(nitro) {
-	const externalServices = nitro.options.graphql?.externalServices || [];
-	for (const service of externalServices) try {
-		consola.info(`[graphql:${service.name}] Processing external service`);
-		await downloadAndSaveSchema(service, nitro.options.buildDir);
-		const schema = await loadExternalSchema(service, nitro.options.buildDir);
-		if (!schema) {
-			consola.warn(`[graphql:${service.name}] Failed to load schema, skipping`);
-			continue;
-		}
-		const documentPatterns = service.documents || [];
-		let loadDocs = [];
-		if (documentPatterns.length > 0) try {
-			loadDocs = await loadGraphQLDocuments(documentPatterns);
-			if (!loadDocs || loadDocs.length === 0) {
-				consola.warn(`[graphql:${service.name}] No GraphQL documents found, skipping service generation`);
-				continue;
-			}
-		} catch (error) {
-			consola.warn(`[graphql:${service.name}] No documents found, skipping service generation:`, error);
-			continue;
-		}
-		const types = await generateExternalClientTypes(service, schema, loadDocs);
-		if (types === false) {
-			consola.warn(`[graphql:${service.name}] Type generation failed`);
-			continue;
-		}
-		const placeholders = {
-			...getDefaultPaths(nitro),
-			serviceName: service.name
-		};
-		const typesConfig = getTypesConfig(nitro);
-		const sdkConfig = getSdkConfig(nitro);
-		const serviceTypesPath = resolveFilePath(service.paths?.types ?? typesConfig.external, typesConfig.enabled, true, "{typesDir}/nitro-graphql-client-{serviceName}.d.ts", placeholders);
-		if (serviceTypesPath) {
-			mkdirSync(dirname(serviceTypesPath), { recursive: true });
-			writeFileSync(serviceTypesPath, types.types, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated types at: ${serviceTypesPath}`);
-		}
-		const serviceSdkPath = resolveFilePath(service.paths?.sdk ?? sdkConfig.external, sdkConfig.enabled, true, "{clientGraphql}/{serviceName}/sdk.ts", placeholders);
-		if (serviceSdkPath) {
-			mkdirSync(dirname(serviceSdkPath), { recursive: true });
-			writeFileSync(serviceSdkPath, types.sdk, "utf-8");
-			consola.success(`[graphql:${service.name}] Generated SDK at: ${serviceSdkPath}`);
-		}
-		if (nitro.options.framework?.name === "nuxt") generateExternalOfetchClient(nitro, service, service.endpoint);
-		consola.success(`[graphql:${service.name}] External service types generated successfully`);
-	} catch (error) {
-		consola.error(`[graphql:${service.name}] External service generation failed:`, error);
-	}
-}
-
-//#endregion
-export { clientTypeGeneration, serverTypeGeneration };

package/dist/virtual/debug-info.d.ts

@@ -1,9 +0,0 @@
-//#region src/virtual/debug-info.d.ts
-/**
- * Virtual module stub for #nitro-graphql/debug-info
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const debugInfo: Record<string, any>;
-//#endregion
-export { debugInfo };

package/dist/virtual/debug-info.js

@@ -1,26 +0,0 @@
-//#region src/virtual/debug-info.ts
-/**
-* Virtual module stub for #nitro-graphql/debug-info
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const debugInfo = {
-	isDev: false,
-	framework: "",
-	graphqlFramework: "",
-	federation: {},
-	scanned: {
-		schemas: 0,
-		schemaFiles: [],
-		resolvers: 0,
-		resolverFiles: [],
-		directives: 0,
-		directiveFiles: [],
-		documents: 0,
-		documentFiles: []
-	},
-	virtualModules: {}
-};
-
-//#endregion
-export { debugInfo };

package/dist/virtual/graphql-config.d.ts

@@ -1,9 +0,0 @@
-//#region src/virtual/graphql-config.d.ts
-/**
- * Virtual module stub for #nitro-graphql/graphql-config
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const importedConfig: {};
-//#endregion
-export { importedConfig };

package/dist/virtual/graphql-config.js

@@ -1,10 +0,0 @@
-//#region src/virtual/graphql-config.ts
-/**
-* Virtual module stub for #nitro-graphql/graphql-config
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const importedConfig = {};
-
-//#endregion
-export { importedConfig };

package/dist/virtual/module-config.d.ts

@@ -1,9 +0,0 @@
-//#region src/virtual/module-config.d.ts
-/**
- * Virtual module stub for #nitro-graphql/module-config
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const moduleConfig: Record<string, any>;
-//#endregion
-export { moduleConfig };

package/dist/virtual/module-config.js

@@ -1,10 +0,0 @@
-//#region src/virtual/module-config.ts
-/**
-* Virtual module stub for #nitro-graphql/module-config
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const moduleConfig = {};
-
-//#endregion
-export { moduleConfig };

package/dist/virtual/server-directives.d.ts

@@ -1,11 +0,0 @@
-//#region src/virtual/server-directives.d.ts
-/**
- * Virtual module stub for #nitro-graphql/server-directives
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const directives: Array<{
-  directive: any;
-}>;
-//#endregion
-export { directives };

package/dist/virtual/server-directives.js

@@ -1,10 +0,0 @@
-//#region src/virtual/server-directives.ts
-/**
-* Virtual module stub for #nitro-graphql/server-directives
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const directives = [];
-
-//#endregion
-export { directives };

package/dist/virtual/server-resolvers.d.ts

@@ -1,11 +0,0 @@
-//#region src/virtual/server-resolvers.d.ts
-/**
- * Virtual module stub for #nitro-graphql/server-resolvers
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const resolvers: Array<{
-  resolver: any;
-}>;
-//#endregion
-export { resolvers };

package/dist/virtual/server-resolvers.js

@@ -1,10 +0,0 @@
-//#region src/virtual/server-resolvers.ts
-/**
-* Virtual module stub for #nitro-graphql/server-resolvers
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const resolvers = [];
-
-//#endregion
-export { resolvers };

package/dist/virtual/server-schemas.d.ts

@@ -1,11 +0,0 @@
-//#region src/virtual/server-schemas.d.ts
-/**
- * Virtual module stub for #nitro-graphql/server-schemas
- * This file is only used during build/bundling to prevent import resolution errors.
- * At runtime, Nitro will override this with the actual virtual module.
- */
-declare const schemas: Array<{
-  def: string;
-}>;
-//#endregion
-export { schemas };

package/dist/virtual/server-schemas.js

@@ -1,10 +0,0 @@
-//#region src/virtual/server-schemas.ts
-/**
-* Virtual module stub for #nitro-graphql/server-schemas
-* This file is only used during build/bundling to prevent import resolution errors.
-* At runtime, Nitro will override this with the actual virtual module.
-*/
-const schemas = [];
-
-//#endregion
-export { schemas };