@ptdgrp/typedgql 1.0.0-beta.16 → 1.0.0-beta.20

package/dist/{schema-loader-CsabdnfI.mjs → config-loader-DZ7d_CWR.mjs}

@@ -1,8 +1,11 @@
+import { readFile } from "node:fs/promises";
+import { normalize, resolve } from "node:path";
 import { GraphQLEnumType, GraphQLInputObjectType, GraphQLInterfaceType, GraphQLList, GraphQLNonNull, GraphQLObjectType, GraphQLScalarType, GraphQLUnionType, buildClientSchema, buildSchema, getIntrospectionQuery } from "graphql";
-import { mkdir, readFile, rm, writeFile } from "fs/promises";
+import { mkdir, readFile as readFile$1, rm, writeFile } from "fs/promises";
 import { createWriteStream } from "fs";
-import { join, resolve } from "path";
+import { join, normalize as normalize$1, resolve as resolve$1 } from "path";
 import ts from "typescript";
+import { parse } from "smol-toml";
 
 //#region src/codegen/utils.ts
 /**
@@ -83,62 +86,63 @@ var JSImportCollector = class {
 		return Array.from(map.entries()).sort((a, b) => a[0].localeCompare(b[0]));
 	}
 };
-const RUNTIME_ENTRY_SOURCE = "../../dist/index.mjs";
+const DEFAULT_RUNTIME_ENTRY_SOURCE = "../../dist/index.mjs";
+const DEFAULT_ROOT_RUNTIME_ENTRY_SOURCE = "../dist/index.mjs";
 const TYPE_HIERARCHY_SOURCE = "../type-hierarchy";
 const ENUM_INPUT_METADATA_SOURCE = "../enum-input-metadata";
 const SCALAR_TYPES_SOURCE = "../scalar-types";
 const SCALAR_TYPES_NAMESPACE = "UserScalarTypes";
 const CODEGEN_IMPORT_SOURCE_MAP = {
 	AcceptableVariables: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	UnresolvedVariables: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	DirectiveArgs: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	Selection: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	ShapeOf: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	VariablesOf: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	ValueOrThunk: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	FragmentSpread: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "type"
 	},
 	createSelection: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	},
 	withOperationName: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	},
 	createSchemaType: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	},
 	registerSchemaTypeFactory: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	},
 	resolveRegisteredSchemaType: {
-		source: RUNTIME_ENTRY_SOURCE,
+		source: DEFAULT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	},
 	ENUM_INPUT_METADATA: {
@@ -158,10 +162,73 @@ const CODEGEN_IMPORT_SOURCE_MAP = {
 		kind: "type"
 	},
 	EnumInputMetadataBuilder: {
-		source: "../dist/index.mjs",
+		source: DEFAULT_ROOT_RUNTIME_ENTRY_SOURCE,
 		kind: "value"
 	}
 };
+function createCodegenImportSourceMap(options) {
+	const runtimeEntrySource = options.runtimeEntrySource ?? DEFAULT_RUNTIME_ENTRY_SOURCE;
+	const rootRuntimeEntrySource = options.rootRuntimeEntrySource ?? DEFAULT_ROOT_RUNTIME_ENTRY_SOURCE;
+	return {
+		...CODEGEN_IMPORT_SOURCE_MAP,
+		AcceptableVariables: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		UnresolvedVariables: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		DirectiveArgs: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		Selection: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		ShapeOf: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		VariablesOf: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		ValueOrThunk: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		FragmentSpread: {
+			source: runtimeEntrySource,
+			kind: "type"
+		},
+		createSelection: {
+			source: runtimeEntrySource,
+			kind: "value"
+		},
+		withOperationName: {
+			source: runtimeEntrySource,
+			kind: "value"
+		},
+		createSchemaType: {
+			source: runtimeEntrySource,
+			kind: "value"
+		},
+		registerSchemaTypeFactory: {
+			source: runtimeEntrySource,
+			kind: "value"
+		},
+		resolveRegisteredSchemaType: {
+			source: runtimeEntrySource,
+			kind: "value"
+		},
+		EnumInputMetadataBuilder: {
+			source: rootRuntimeEntrySource,
+			kind: "value"
+		}
+	};
+}
 
 //#endregion
 //#region src/codegen/writer.ts
@@ -203,9 +270,10 @@ var Writer = class {
 	importedTypes = /* @__PURE__ */ new Set();
 	usesScalarTypeNamespaceImport = false;
 	importFinalized = false;
-	constructor(stream, options) {
+	constructor(stream, options, importSourceMap = CODEGEN_IMPORT_SOURCE_MAP) {
 		this.stream = stream;
 		this.options = options;
+		this.importSourceMap = importSourceMap;
 		this.indent = options.indent ?? "    ";
 	}
 	/**
@@ -387,7 +455,7 @@ var Writer = class {
 	}
 	writeMappedScalarImports() {
 		if (!this.usesScalarTypeNamespaceImport) return;
-		const source = CODEGEN_IMPORT_SOURCE_MAP.SCALAR_TYPE_NAMESPACE.source;
+		const source = this.importSourceMap.SCALAR_TYPE_NAMESPACE.source;
 		const importSource = this.isUnderGlobalDir() ? source.replace(/^\.\.\//, "./") : source;
 		this.stream.write(`import type { ${SCALAR_TYPES_NAMESPACE} } from '${importSource}';\n`);
 	}
@@ -468,8 +536,8 @@ var SelectionWriter = class extends Writer {
 	fieldCategoryMap;
 	hasArgs;
 	_declaredFieldNames;
-	constructor(modelType, ctx, stream, options) {
-		super(stream, options);
+	constructor(modelType, ctx, stream, options, importSourceMap) {
+		super(stream, options, importSourceMap);
 		this.modelType = modelType;
 		this.ctx = ctx;
 		this.selectionTypeName = `${this.modelType.name}${options.selectionSuffix ?? "Selection"}`;
@@ -549,7 +617,7 @@ var SelectionWriter = class extends Writer {
 		return "SCALAR";
 	}
 	prepareImports() {
-		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), CODEGEN_IMPORT_SOURCE_MAP);
+		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), this.importSourceMap);
 		imports.useMapped("DirectiveArgs");
 		imports.useMapped("Selection");
 		if (this.hasArgs) {
@@ -1175,7 +1243,7 @@ const COMMENT$1 = `/*
  * Any instance of this interface is immutable,
  * all the properties and functions can only be used to create new instances,
  * they cannot modify the current instance.
- * 
+ *
  * So any instance of this interface is reuseable.
  */
 `;
@@ -1503,12 +1571,12 @@ var TypeHierarchyGraph = class {
 //#endregion
 //#region src/codegen/writers/enum-input-metadata.ts
 var EnumInputMetadataWriter = class EnumInputMetadataWriter extends Writer {
-	constructor(schema, stream, options) {
-		super(stream, options);
+	constructor(schema, stream, options, importSourceMap) {
+		super(stream, options, importSourceMap);
 		this.schema = schema;
 	}
 	prepareImports() {
-		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), CODEGEN_IMPORT_SOURCE_MAP);
+		const imports = new JSImportCollector((stmt) => this.importStatement(stmt), this.importSourceMap);
 		imports.useMapped("EnumInputMetadataBuilder");
 		imports.emit();
 	}
@@ -1610,12 +1678,123 @@ function analyzeScalarTypeDeclarations(source) {
 	return { exportedNames };
 }
 
+//#endregion
+//#region src/codegen/prettier-formatter.ts
+let prettierInstance = void 0;
+let prettierDetected = false;
+/**
+* Detect and dynamically import prettier if available.
+* Returns null if prettier is not installed.
+*/
+async function detectPrettier() {
+	if (prettierDetected) return prettierInstance ?? null;
+	prettierDetected = true;
+	try {
+		prettierInstance = await import("prettier");
+		return prettierInstance;
+	} catch {
+		prettierInstance = null;
+		return null;
+	}
+}
+/**
+* Format TypeScript code using prettier if available.
+* Returns the original code if prettier is not installed or formatting fails.
+*
+* @param code - TypeScript code to format
+* @param filePath - File path for prettier config resolution
+* @returns Formatted code or original code if formatting fails
+*/
+async function formatWithPrettier(code, filePath) {
+	const prettier = await detectPrettier();
+	if (!prettier) return code;
+	try {
+		const config = await prettier.resolveConfig(filePath);
+		return await prettier.format(code, {
+			...config,
+			parser: "typescript",
+			filepath: filePath
+		});
+	} catch (error) {
+		console.warn(`[typedgql] Failed to format ${filePath} with prettier: ${error.message}`);
+		return code;
+	}
+}
+/**
+* Check if prettier is available.
+* This is a lightweight check that doesn't actually import prettier.
+*/
+async function isPrettierAvailable() {
+	return await detectPrettier() !== null;
+}
+
+//#endregion
+//#region src/codegen/buffered-stream.ts
+/**
+* A buffered write stream that collects content in memory
+* instead of writing directly to disk.
+* This allows post-processing (like prettier formatting) before writing.
+*/
+var BufferedStream = class {
+	buffer = [];
+	ended = false;
+	path;
+	constructor(path) {
+		this.path = path;
+	}
+	/**
+	* Write content to the buffer.
+	*/
+	write(chunk) {
+		if (this.ended) throw new Error("Cannot write to ended stream");
+		this.buffer.push(chunk);
+		return true;
+	}
+	/**
+	* Mark the stream as ended.
+	* Returns a promise that resolves when the stream is closed.
+	*/
+	end(callback) {
+		this.ended = true;
+		if (callback) callback();
+		return Promise.resolve();
+	}
+	/**
+	* Get the buffered content as a string.
+	*/
+	getContent() {
+		return this.buffer.join("");
+	}
+	/**
+	* Write the buffered content to disk.
+	*/
+	async flush(formatter) {
+		let content = this.getContent();
+		if (formatter) content = await formatter(content, this.path);
+		await writeFile(this.path, content, "utf-8");
+	}
+	/**
+	* Create a WriteStream-compatible interface for this buffered stream.
+	* This allows it to be used with existing writer classes.
+	*/
+	toWriteStream() {
+		return {
+			write: (chunk) => this.write(chunk),
+			end: (callback) => {
+				this.end(callback);
+			}
+		};
+	}
+};
+
 //#endregion
 //#region src/codegen/generator.ts
 /** Default output directory: node_modules/@ptdgrp/typedgql/__generated */
-const DEFAULT_TARGET_DIR = resolve(process.cwd(), "node_modules/@ptdgrp/typedgql/__generated");
+const DEFAULT_TARGET_DIR = resolve$1(process.cwd(), "node_modules/@ptdgrp/typedgql/__generated");
 /** Parent package dir: node_modules/@ptdgrp/typedgql */
-const PACKAGE_DIR = resolve(process.cwd(), "node_modules/@ptdgrp/typedgql");
+const PACKAGE_DIR = resolve$1(process.cwd(), "node_modules/@ptdgrp/typedgql");
+const RUNTIME_PACKAGE_NAME = "@ptdgrp/typedgql/runtime";
+const GENERATED_FILE_BANNER = "/* eslint-disable */\n// This file was generated by @ptdgrp/typedgql. Do not edit it manually.\n\n";
 /** Field names reserved by the runtime SelectionNode implementation. */
 const RESERVED_FIELDS = new Set([
 	"constructor",
@@ -1635,6 +1814,9 @@ const RESERVED_FIELDS = new Set([
 	"toFragmentString"
 ]);
 var Generator = class {
+	usePrettier = false;
+	isCustomOutputDir = false;
+	bufferedStreams = [];
 	constructor(options) {
 		this.options = options;
 	}
@@ -1642,6 +1824,62 @@ var Generator = class {
 	get targetDir() {
 		return this.options.targetDir ?? DEFAULT_TARGET_DIR;
 	}
+	/**
+	* Check if we should use prettier formatting.
+	* Only enabled when using custom outputDir (not in node_modules).
+	*/
+	async initializePrettier() {
+		const targetDir = this.targetDir;
+		this.isCustomOutputDir = !normalize$1(targetDir).includes("node_modules");
+		if (this.options.prettier === false) {
+			this.usePrettier = false;
+			return;
+		}
+		if (this.options.prettier === true || this.isCustomOutputDir) {
+			this.usePrettier = await isPrettierAvailable();
+			if (this.usePrettier) console.log("[typedgql] Prettier detected, will format generated files");
+		}
+	}
+	/**
+	* Create a stream for writing generated code.
+	* Uses BufferedStream when prettier formatting is enabled.
+	*/
+	createCodeStream(path) {
+		const writeBanner = (stream) => {
+			stream.write(GENERATED_FILE_BANNER);
+			return stream;
+		};
+		if (this.usePrettier) {
+			const buffered = new BufferedStream(path);
+			this.bufferedStreams.push(buffered);
+			return writeBanner(buffered.toWriteStream());
+		}
+		return writeBanner(createWriteStream(path));
+	}
+	get rootRuntimeImportSource() {
+		return this.usesPackageInternalRuntimeImports ? "../dist/index.mjs" : RUNTIME_PACKAGE_NAME;
+	}
+	get nestedRuntimeImportSource() {
+		return this.usesPackageInternalRuntimeImports ? "../../dist/index.mjs" : RUNTIME_PACKAGE_NAME;
+	}
+	get usesPackageInternalRuntimeImports() {
+		return normalize$1(this.targetDir) === normalize$1(DEFAULT_TARGET_DIR);
+	}
+	get generatedImportSourceMap() {
+		return createCodegenImportSourceMap({
+			runtimeEntrySource: this.nestedRuntimeImportSource,
+			rootRuntimeEntrySource: this.rootRuntimeImportSource
+		});
+	}
+	/**
+	* Flush all buffered streams with prettier formatting.
+	*/
+	async flushBufferedStreams() {
+		if (this.bufferedStreams.length === 0) return;
+		console.log(`[typedgql] Formatting ${this.bufferedStreams.length} files with prettier...`);
+		await Promise.all(this.bufferedStreams.map((stream) => stream.flush(this.usePrettier ? formatWithPrettier : void 0)));
+		this.bufferedStreams = [];
+	}
 	async generate() {
 		const schema = await this.options.schemaLoader();
 		this.validateSchema(schema);
@@ -1651,6 +1889,7 @@ var Generator = class {
 			force: true
 		});
 		await mkdir(this.targetDir, { recursive: true });
+		await this.initializePrettier();
 		const typeHierarchy = new TypeHierarchyGraph(schema);
 		const selectionTypes = [];
 		const inputTypes = [];
@@ -1728,10 +1967,11 @@ var Generator = class {
 		if (this.hasScalarTypes()) promises.push(this.generateScalarTypes());
 		promises.push(this.writeIndex(schema, ctx));
 		await Promise.all(promises);
+		await this.flushBufferedStreams();
 		if (this.options.targetDir === void 0) await this.writePackageEntrypoint(schema, ctx);
 	}
 	createSelectionWriter(modelType, ctx, stream, options) {
-		return new SelectionWriter(modelType, ctx, stream, options);
+		return new SelectionWriter(modelType, ctx, stream, options, this.generatedImportSourceMap);
 	}
 	additionalExportedTypeNamesForSelection(_modelType, _ctx) {
 		return [];
@@ -1742,7 +1982,8 @@ var Generator = class {
 		const defaultSelectionNameMap = /* @__PURE__ */ new Map();
 		const suffix = this.options?.selectionSuffix ?? "Selection";
 		const promises = ctx.selectionTypes.map(async (type) => {
-			const stream = createStream(join(dir, `${toKebabCase(`${type.name}${suffix}`)}.ts`));
+			const selectionTypeName = `${type.name}${suffix}`;
+			const stream = this.createCodeStream(join(dir, `${toKebabCase(selectionTypeName)}.ts`));
 			const writer = this.createSelectionWriter(type, ctx, stream, this.options);
 			emptySelectionNameMap.set(type, writer.emptySelectionName);
 			if (writer.defaultSelectionName !== void 0) defaultSelectionNameMap.set(type, writer.defaultSelectionName);
@@ -1750,7 +1991,7 @@ var Generator = class {
 			await endStream(stream);
 		});
 		await Promise.all([...promises, (async () => {
-			const stream = createStream(join(dir, "index.ts"));
+			const stream = this.createCodeStream(join(dir, "index.ts"));
 			for (const type of ctx.selectionTypes) {
 				const selectionTypeName = `${type.name}${suffix}`;
 				const selectionFileName = toKebabCase(selectionTypeName);
@@ -1770,7 +2011,7 @@ var Generator = class {
 	async generateInputTypes(inputTypes) {
 		const dir = join(this.targetDir, "inputs");
 		const promises = inputTypes.map(async (type) => {
-			const stream = createStream(join(dir, `${toKebabCase(type.name)}.ts`));
+			const stream = this.createCodeStream(join(dir, `${toKebabCase(type.name)}.ts`));
 			new InputWriter(type, stream, this.options).write();
 			await stream.end();
 		});
@@ -1779,35 +2020,35 @@ var Generator = class {
 	async generateEnumTypes(enumTypes) {
 		const dir = join(this.targetDir, "enums");
 		const promises = enumTypes.map(async (type) => {
-			const stream = createStream(join(dir, `${toKebabCase(type.name)}.ts`));
+			const stream = this.createCodeStream(join(dir, `${toKebabCase(type.name)}.ts`));
 			new EnumWriter(type, stream, this.options).write();
 			await stream.end();
 		});
 		await Promise.all([...promises, this.writeSimpleIndex(dir, enumTypes, true)]);
 	}
 	async generateTypeHierarchy(schema, typeHierarchy) {
-		const stream = createStream(join(this.targetDir, "type-hierarchy.ts"));
+		const stream = this.createCodeStream(join(this.targetDir, "type-hierarchy.ts"));
 		new TypeHierarchyWriter(schema, typeHierarchy, stream, this.options).write();
 		await endStream(stream);
 	}
 	async generateEnumInputMetadata(schema) {
-		const stream = createStream(join(this.targetDir, "enum-input-metadata.ts"));
-		new EnumInputMetadataWriter(schema, stream, this.options).write();
+		const stream = this.createCodeStream(join(this.targetDir, "enum-input-metadata.ts"));
+		new EnumInputMetadataWriter(schema, stream, this.options, this.generatedImportSourceMap).write();
 		await endStream(stream);
 	}
 	async writeSimpleIndex(dir, types, typeOnly = true) {
-		const stream = createStream(join(dir, "index.ts"));
+		const stream = this.createCodeStream(join(dir, "index.ts"));
 		const keyword = typeOnly ? "export type" : "export";
 		for (const type of types) stream.write(`${keyword} {${type.name}} from './${toKebabCase(type.name)}';\n`);
 		await stream.end();
 	}
 	async generateAsyncRuntime() {
-		const stream = createStream(join(this.targetDir, "client-runtime.ts"));
-		stream.write(async_runtime_default);
+		const stream = this.createCodeStream(join(this.targetDir, "client-runtime.ts"));
+		stream.write(async_runtime_default.replaceAll("../dist/index.mjs", this.rootRuntimeImportSource));
 		await endStream(stream);
 	}
 	async generateScalarTypes() {
-		const stream = createStream(join(this.targetDir, "scalar-types.ts"));
+		const stream = this.createCodeStream(join(this.targetDir, "scalar-types.ts"));
 		const analysis = analyzeScalarTypeDeclarations(this.options.scalarTypeDeclarations);
 		const code = this.options.scalarTypeDeclarations?.trim();
 		if (code && code.length !== 0) {
@@ -1836,10 +2077,10 @@ var Generator = class {
 		}
 	}
 	async writeIndex(schema, ctx) {
-		const stream = createStream(join(this.targetDir, "index.ts"));
+		const stream = this.createCodeStream(join(this.targetDir, "index.ts"));
 		const selectionSuffix = this.options.selectionSuffix ?? "Selection";
-		stream.write(`import type { Selection, ExecutableSelection, SchemaType, ShapeOf, VariablesOf } from "../dist/index.mjs";\n`);
-		stream.write(`import { FragmentRef, createSelection, resolveRegisteredSchemaType } from "../dist/index.mjs";\n`);
+		stream.write(`import type { Selection, ExecutableSelection, SchemaType, ShapeOf, VariablesOf } from "${this.rootRuntimeImportSource}";\n`);
+		stream.write(`import { FragmentRef, createSelection, resolveRegisteredSchemaType } from "${this.rootRuntimeImportSource}";\n`);
 		for (const type of ctx.selectionTypes) {
 			const selectionTypeName = `${type.name}${selectionSuffix}`;
 			stream.write(`import type { ${selectionTypeName} } from "./selections/${toKebabCase(selectionTypeName)}";\n`);
@@ -1888,13 +2129,14 @@ var Generator = class {
 	async writePackageEntrypoint(schema, ctx) {
 		await mkdir(PACKAGE_DIR, { recursive: true });
 		const indexStream = createStream(join(PACKAGE_DIR, "index.ts"));
+		indexStream.write(GENERATED_FILE_BANNER);
 		this.writePackageIndexCode(indexStream, schema, ctx);
 		await endStream(indexStream);
 		await this.patchPackageJsonForGeneratedEntrypoint();
 	}
 	async patchPackageJsonForGeneratedEntrypoint() {
 		const packageJsonPath = join(PACKAGE_DIR, "package.json");
-		const raw = await readFile(packageJsonPath, "utf8");
+		const raw = await readFile$1(packageJsonPath, "utf8");
 		const pkg = JSON.parse(raw);
 		const exportsMap = typeof pkg.exports === "object" && pkg.exports !== null ? pkg.exports : {};
 		const rootExportRaw = exportsMap["."];
@@ -2022,9 +2264,62 @@ async function loadRemoteSchema(endpoint, headers) {
 	return buildClientSchema(data);
 }
 async function loadLocalSchema(location) {
-	return buildSchema(await readFile(location, { encoding: "utf8" }));
+	return buildSchema(await readFile$1(location, { encoding: "utf8" }));
+}
+
+//#endregion
+//#region src/codegen/config-loader.ts
+/**
+* Validate that the output directory is not inside node_modules.
+* @throws Error if the path is inside node_modules
+*/
+function validateOutputDir(outputDir) {
+	if (normalize(outputDir).includes("node_modules")) throw new Error(`Invalid outputDir: "${outputDir}". Output directory cannot be inside node_modules. Please specify a path outside node_modules, such as './src/__generated' or './__generated'.`);
+}
+/**
+* Load configuration from .typedgqlrc.toml file.
+*
+* @param configPath - Path to the config file (defaults to .typedgqlrc.toml in cwd)
+* @returns Parsed configuration object or undefined if file doesn't exist
+*/
+async function loadConfig(configPath) {
+	const path = configPath ?? resolve(process.cwd(), ".typedgqlrc.toml");
+	try {
+		const config = parse(await readFile(path, "utf-8"));
+		if (config.outputDir && !config.targetDir) config.targetDir = config.outputDir;
+		const outputPath = config.outputDir || config.targetDir;
+		if (outputPath) validateOutputDir(outputPath);
+		return config;
+	} catch (error) {
+		if (error.code === "ENOENT") return;
+		throw new Error(`Failed to load config from ${path}: ${error.message}`);
+	}
+}
+/**
+* Merge configuration from file with programmatic options.
+* Programmatic options take precedence over file config.
+*
+* @param fileConfig - Configuration loaded from .typedgqlrc.toml
+* @param programmaticConfig - Configuration passed programmatically
+* @returns Merged configuration
+*/
+function mergeConfig(fileConfig, programmaticConfig) {
+	let merged;
+	if (!fileConfig) merged = programmaticConfig;
+	else merged = {
+		...fileConfig,
+		...programmaticConfig,
+		schemaHeaders: {
+			...fileConfig.schemaHeaders,
+			...programmaticConfig.schemaHeaders
+		}
+	};
+	if (merged.outputDir && !merged.targetDir) merged.targetDir = merged.outputDir;
+	const outputPath = merged.outputDir || merged.targetDir;
+	if (outputPath) validateOutputDir(outputPath);
+	return merged;
 }
 
 //#endregion
-export { loadRemoteSchema as n, Generator as r, loadLocalSchema as t };
-//# sourceMappingURL=schema-loader-CsabdnfI.mjs.map
+export { Generator as a, loadRemoteSchema as i, mergeConfig as n, loadLocalSchema as r, loadConfig as t };
+//# sourceMappingURL=config-loader-DZ7d_CWR.mjs.map