@soda-gql/codegen 0.11.19 → 0.11.21

package/dist/index.mjs

@@ -6,271 +6,6 @@ import { basename, dirname, extname, join, relative, resolve } from "node:path";
 import { build } from "esbuild";
 import { createHash } from "node:crypto";
 
-//#region packages/codegen/src/graphql-compat/emitter.ts
-/**
-* Emit TypeScript code for an operation.
-*/
-const emitOperation = (operation, options) => {
-	const lines = [];
-	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
-	const exportName = `${operation.name}Compat`;
-	const operationType = operation.kind;
-	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${operationType}, $var }) =>`);
-	lines.push(`  ${operationType}.compat({`);
-	lines.push(`    name: ${JSON.stringify(operation.name)},`);
-	if (operation.variables.length > 0) {
-		lines.push(`    variables: { ${emitVariables(operation.variables)} },`);
-	}
-	lines.push(`    fields: ({ f, $ }) => ({`);
-	const fieldLinesResult = emitSelections(operation.selections, 3, operation.variables, schema);
-	if (fieldLinesResult.isErr()) {
-		return err(fieldLinesResult.error);
-	}
-	lines.push(fieldLinesResult.value);
-	lines.push(`    }),`);
-	lines.push(`  }),`);
-	lines.push(`);`);
-	return ok(lines.join("\n"));
-};
-/**
-* Emit TypeScript code for a fragment.
-*/
-const emitFragment = (fragment, options) => {
-	const lines = [];
-	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
-	const hasVariables = fragment.variables.length > 0;
-	const exportName = `${fragment.name}Fragment`;
-	const destructure = hasVariables ? "fragment, $var" : "fragment";
-	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${destructure} }) =>`);
-	lines.push(`  fragment.${fragment.onType}({`);
-	if (hasVariables) {
-		lines.push(`    variables: { ${emitVariables(fragment.variables)} },`);
-	}
-	const fieldsContext = hasVariables ? "{ f, $ }" : "{ f }";
-	lines.push(`    fields: (${fieldsContext}) => ({`);
-	const fieldLinesResult = emitSelections(fragment.selections, 3, fragment.variables, schema);
-	if (fieldLinesResult.isErr()) {
-		return err(fieldLinesResult.error);
-	}
-	lines.push(fieldLinesResult.value);
-	lines.push(`    }),`);
-	lines.push(`  }),`);
-	lines.push(`);`);
-	return ok(lines.join("\n"));
-};
-/**
-* Emit variable definitions.
-*/
-const emitVariables = (variables) => {
-	return variables.map((v) => `...$var(${JSON.stringify(v.name)}).${v.typeName}(${JSON.stringify(v.modifier)})`).join(", ");
-};
-/**
-* Emit field selections (public API).
-* Converts variable array to Set<string> and delegates to internal implementation.
-*/
-const emitSelections = (selections, indent, variables, schema) => {
-	const variableNames = new Set(variables.map((v) => v.name));
-	return emitSelectionsInternal(selections, indent, variableNames, schema);
-};
-/**
-* Internal implementation for emitting field selections.
-* Takes variableNames as Set<string> for recursive calls.
-*/
-const emitSelectionsInternal = (selections, indent, variableNames, schema) => {
-	const lines = [];
-	const inlineFragments = [];
-	const otherSelections = [];
-	for (const sel of selections) {
-		if (sel.kind === "inlineFragment") {
-			inlineFragments.push(sel);
-		} else {
-			otherSelections.push(sel);
-		}
-	}
-	for (const sel of otherSelections) {
-		const result = emitSingleSelection(sel, indent, variableNames, schema);
-		if (result.isErr()) {
-			return err(result.error);
-		}
-		lines.push(result.value);
-	}
-	if (inlineFragments.length > 0) {
-		const unionResult = emitInlineFragmentsAsUnion(inlineFragments, indent, variableNames, schema);
-		if (unionResult.isErr()) {
-			return err(unionResult.error);
-		}
-		lines.push(unionResult.value);
-	}
-	return ok(lines.join("\n"));
-};
-/**
-* Emit a single selection (field or fragment spread).
-*/
-const emitSingleSelection = (sel, indent, variableNames, schema) => {
-	const padding = "  ".repeat(indent);
-	switch (sel.kind) {
-		case "field": return emitFieldSelection(sel, indent, variableNames, schema);
-		case "fragmentSpread": return ok(`${padding}...${sel.name}Fragment.spread(),`);
-		case "inlineFragment": return ok("");
-	}
-};
-/**
-* Emit inline fragments grouped as a union selection.
-* Format: { TypeA: ({ f }) => ({ ...fields }), TypeB: ({ f }) => ({ ...fields }) }
-*/
-const emitInlineFragmentsAsUnion = (inlineFragments, indent, variableNames, schema) => {
-	const padding = "  ".repeat(indent);
-	for (const frag of inlineFragments) {
-		if (frag.onType === "") {
-			return err({
-				code: "GRAPHQL_INLINE_FRAGMENT_WITHOUT_TYPE",
-				message: "Inline fragments without type condition are not supported. Use `... on TypeName { }` syntax."
-			});
-		}
-	}
-	for (const frag of inlineFragments) {
-		if (schema && !schema.objects.has(frag.onType)) {
-			let isUnionMember = false;
-			for (const [, unionDef] of schema.unions) {
-				if (unionDef.members.has(frag.onType)) {
-					isUnionMember = true;
-					break;
-				}
-			}
-			if (!isUnionMember) {
-				return err({
-					code: "GRAPHQL_INLINE_FRAGMENT_ON_INTERFACE",
-					message: `Inline fragments on interface type "${frag.onType}" are not supported. Use union types instead.`,
-					onType: frag.onType
-				});
-			}
-		}
-	}
-	const entries = [];
-	for (const frag of inlineFragments) {
-		const innerPadding = "  ".repeat(indent + 1);
-		const fieldsResult = emitSelectionsInternal(frag.selections, indent + 2, variableNames, schema);
-		if (fieldsResult.isErr()) {
-			return err(fieldsResult.error);
-		}
-		entries.push(`${innerPadding}${frag.onType}: ({ f }) => ({
-${fieldsResult.value}
-${innerPadding}}),`);
-	}
-	return ok(`${padding}...({
-${entries.join("\n")}
-${padding}}),`);
-};
-/**
-* Emit a single field selection.
-*/
-const emitFieldSelection = (field, indent, variableNames, schema) => {
-	const padding = "  ".repeat(indent);
-	const args = field.arguments;
-	const selections = field.selections;
-	const hasArgs = args && args.length > 0;
-	const hasSelections = selections && selections.length > 0;
-	if (!hasArgs && !hasSelections) {
-		return ok(`${padding}${field.name}: true,`);
-	}
-	let line = `${padding}...f.${field.name}(`;
-	if (hasArgs) {
-		const argsResult = emitArguments(args, variableNames);
-		if (argsResult.isErr()) {
-			return err(argsResult.error);
-		}
-		line += argsResult.value;
-	}
-	line += ")";
-	if (hasSelections) {
-		const hasInlineFragments = selections.some((s) => s.kind === "inlineFragment");
-		if (hasInlineFragments) {
-			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema);
-			if (nestedResult.isErr()) {
-				return err(nestedResult.error);
-			}
-			line += "({\n";
-			line += `${nestedResult.value}\n`;
-			line += `${padding}})`;
-		} else {
-			line += "(({ f }) => ({\n";
-			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema);
-			if (nestedResult.isErr()) {
-				return err(nestedResult.error);
-			}
-			line += `${nestedResult.value}\n`;
-			line += `${padding}}))`;
-		}
-	}
-	line += ",";
-	return ok(line);
-};
-/**
-* Emit field arguments.
-*/
-const emitArguments = (args, variableNames) => {
-	if (args.length === 0) {
-		return ok("");
-	}
-	const argEntries = [];
-	for (const arg of args) {
-		const result = emitValue(arg.value, variableNames);
-		if (result.isErr()) {
-			return err(result.error);
-		}
-		argEntries.push(`${arg.name}: ${result.value}`);
-	}
-	return ok(`{ ${argEntries.join(", ")} }`);
-};
-/**
-* Emit a value (literal or variable reference).
-*/
-const emitValue = (value, variableNames) => {
-	switch (value.kind) {
-		case "variable":
-			if (variableNames.has(value.name)) {
-				return ok(`$.${value.name}`);
-			}
-			return err({
-				code: "GRAPHQL_UNDECLARED_VARIABLE",
-				message: `Variable "$${value.name}" is not declared in the operation`,
-				variableName: value.name
-			});
-		case "int":
-		case "float": return ok(value.value);
-		case "string": return ok(JSON.stringify(value.value));
-		case "boolean": return ok(value.value ? "true" : "false");
-		case "null": return ok("null");
-		case "enum": return ok(JSON.stringify(value.value));
-		case "list": {
-			const values = [];
-			for (const v of value.values) {
-				const result = emitValue(v, variableNames);
-				if (result.isErr()) {
-					return err(result.error);
-				}
-				values.push(result.value);
-			}
-			return ok(`[${values.join(", ")}]`);
-		}
-		case "object": {
-			if (value.fields.length === 0) {
-				return ok("{}");
-			}
-			const entries = [];
-			for (const f of value.fields) {
-				const result = emitValue(f.value, variableNames);
-				if (result.isErr()) {
-					return err(result.error);
-				}
-				entries.push(`${f.name}: ${result.value}`);
-			}
-			return ok(`{ ${entries.join(", ")} }`);
-		}
-	}
-};
-
-//#endregion
 //#region packages/codegen/src/graphql-compat/parser.ts
 /**
 * Parser for .graphql operation files.
@@ -569,13 +304,59 @@ const buildModifier = (structure) => {
 	return structure.inner + structure.lists.join("");
 };
 /**
-* Merge two modifiers by taking the stricter constraint at each level.
-* - Non-null (!) is stricter than nullable (?)
-* - List depths must match
+* Check if source modifier can be assigned to target modifier.
+* Implements GraphQL List Coercion: depth difference of 0 or 1 is allowed.
 *
-* @param a - First modifier
-* @param b - Second modifier
-* @returns Merged modifier or error if incompatible
+* Rules:
+* - A single value can be coerced into a list (depth diff = 1)
+* - At each level, non-null can be assigned to nullable (but not vice versa)
+*
+* @param source - The modifier of the value being assigned (variable's type)
+* @param target - The modifier expected by the position (field argument's type)
+* @returns true if assignment is valid
+*/
+const isModifierAssignable = (source, target) => {
+	const srcStruct = parseModifierStructure(source);
+	const tgtStruct = parseModifierStructure(target);
+	const depthDiff = tgtStruct.lists.length - srcStruct.lists.length;
+	if (depthDiff < 0 || depthDiff > 1) return false;
+	const tgtListsToCompare = depthDiff === 1 ? tgtStruct.lists.slice(1) : tgtStruct.lists;
+	if (depthDiff === 1 && srcStruct.lists.length === 0 && srcStruct.inner === "?" && tgtStruct.lists[0] === "[]!") {
+		return false;
+	}
+	if (srcStruct.inner === "?" && tgtStruct.inner === "!") return false;
+	for (let i = 0; i < srcStruct.lists.length; i++) {
+		const srcList = srcStruct.lists[i];
+		const tgtList = tgtListsToCompare[i];
+		if (srcList === "[]?" && tgtList === "[]!") return false;
+	}
+	return true;
+};
+/**
+* Derive minimum modifier needed to satisfy expected modifier.
+* When List Coercion can apply, returns one level shallower.
+*
+* @param expectedModifier - The modifier expected by the field argument
+* @returns The minimum modifier the variable must have
+*/
+const deriveMinimumModifier = (expectedModifier) => {
+	const struct = parseModifierStructure(expectedModifier);
+	if (struct.lists.length > 0) {
+		return buildModifier({
+			inner: struct.inner,
+			lists: struct.lists.slice(1)
+		});
+	}
+	return expectedModifier;
+};
+/**
+* Merge two modifiers by taking the stricter constraint at each level.
+* - Non-null (!) is stricter than nullable (?)
+* - List depths must match
+*
+* @param a - First modifier
+* @param b - Second modifier
+* @returns Merged modifier or error if incompatible
 */
 const mergeModifiers = (a, b) => {
 	const structA = parseModifierStructure(a);
@@ -650,7 +431,8 @@ const collectVariablesFromValue = (value, expectedTypeName, expectedModifier, sc
 		usages.push({
 			name: value.name,
 			typeName: expectedTypeName,
-			modifier: expectedModifier,
+			expectedModifier,
+			minimumModifier: deriveMinimumModifier(expectedModifier),
 			typeKind
 		});
 		return null;
@@ -760,7 +542,12 @@ const getFieldReturnType = (schema, parentTypeName, fieldName) => {
 };
 /**
 * Merge multiple variable usages into a single InferredVariable.
-* Validates type compatibility and merges modifiers using stricter constraint.
+* Validates type compatibility and merges modifiers using List Coercion rules.
+*
+* The algorithm:
+* 1. Validate all usages have the same type name
+* 2. Merge minimumModifiers to find the candidate (shallowest type that could work)
+* 3. Verify the candidate can satisfy ALL expected modifiers via isModifierAssignable
 */
 const mergeVariableUsages = (variableName, usages) => {
 	if (usages.length === 0) {
@@ -780,9 +567,9 @@ const mergeVariableUsages = (variableName, usages) => {
 			});
 		}
 	}
-	let mergedModifier = first.modifier;
+	let candidateModifier = first.minimumModifier;
 	for (let i = 1; i < usages.length; i++) {
-		const result = mergeModifiers(mergedModifier, usages[i].modifier);
+		const result = mergeModifiers(candidateModifier, usages[i].minimumModifier);
 		if (!result.ok) {
 			return err({
 				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
@@ -790,12 +577,21 @@ const mergeVariableUsages = (variableName, usages) => {
 				variableName
 			});
 		}
-		mergedModifier = result.value;
+		candidateModifier = result.value;
+	}
+	for (const usage of usages) {
+		if (!isModifierAssignable(candidateModifier, usage.expectedModifier)) {
+			return err({
+				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
+				message: `Variable "$${variableName}" with modifier "${candidateModifier}" cannot satisfy expected "${usage.expectedModifier}"`,
+				variableName
+			});
+		}
 	}
 	return ok({
 		name: variableName,
 		typeName: first.typeName,
-		modifier: mergedModifier,
+		modifier: candidateModifier,
 		typeKind: first.typeKind
 	});
 };
@@ -991,7 +787,8 @@ const transformFragment = (frag, schema, resolvedFragmentVariables) => {
 	const allUsages = [...directUsages, ...spreadVariables.map((v) => ({
 		name: v.name,
 		typeName: v.typeName,
-		modifier: v.modifier,
+		expectedModifier: v.modifier,
+		minimumModifier: v.modifier,
 		typeKind: v.typeKind
 	}))];
 	const variablesResult = inferVariablesFromUsages(allUsages);
@@ -1045,6 +842,375 @@ const collectFragmentDependencies = (selections) => {
 	return [...fragments];
 };
 
+//#endregion
+//#region packages/codegen/src/graphql-compat/emitter.ts
+/**
+* Map operation kind to root type name.
+*/
+const getRootTypeName = (kind) => {
+	switch (kind) {
+		case "query": return "Query";
+		case "mutation": return "Mutation";
+		case "subscription": return "Subscription";
+	}
+};
+/**
+* Emit TypeScript code for an operation.
+*/
+const emitOperation = (operation, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	const exportName = `${operation.name}Compat`;
+	const operationType = operation.kind;
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${operationType}, $var }) =>`);
+	lines.push(`  ${operationType}.compat({`);
+	lines.push(`    name: ${JSON.stringify(operation.name)},`);
+	if (operation.variables.length > 0) {
+		lines.push(`    variables: { ${emitVariables(operation.variables)} },`);
+	}
+	const rootTypeName = getRootTypeName(operation.kind);
+	lines.push(`    fields: ({ f, $ }) => ({`);
+	const fieldLinesResult = emitSelections(operation.selections, 3, operation.variables, schema, rootTypeName);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit TypeScript code for a fragment.
+*/
+const emitFragment = (fragment, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	const hasVariables = fragment.variables.length > 0;
+	const exportName = `${fragment.name}Fragment`;
+	const destructure = hasVariables ? "fragment, $var" : "fragment";
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${destructure} }) =>`);
+	lines.push(`  fragment.${fragment.onType}({`);
+	if (hasVariables) {
+		lines.push(`    variables: { ${emitVariables(fragment.variables)} },`);
+	}
+	const fieldsContext = hasVariables ? "{ f, $ }" : "{ f }";
+	lines.push(`    fields: (${fieldsContext}) => ({`);
+	const fieldLinesResult = emitSelections(fragment.selections, 3, fragment.variables, schema, fragment.onType);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit variable definitions.
+*/
+const emitVariables = (variables) => {
+	return variables.map((v) => `...$var(${JSON.stringify(v.name)}).${v.typeName}(${JSON.stringify(v.modifier)})`).join(", ");
+};
+/**
+* Emit field selections (public API).
+* Converts variable array to Set<string> and delegates to internal implementation.
+*/
+const emitSelections = (selections, indent, variables, schema, parentTypeName) => {
+	const variableNames = new Set(variables.map((v) => v.name));
+	return emitSelectionsInternal(selections, indent, variableNames, schema, parentTypeName);
+};
+/**
+* Internal implementation for emitting field selections.
+* Takes variableNames as Set<string> for recursive calls.
+*/
+const emitSelectionsInternal = (selections, indent, variableNames, schema, parentTypeName) => {
+	const lines = [];
+	const inlineFragments = [];
+	const otherSelections = [];
+	for (const sel of selections) {
+		if (sel.kind === "inlineFragment") {
+			inlineFragments.push(sel);
+		} else {
+			otherSelections.push(sel);
+		}
+	}
+	for (const sel of otherSelections) {
+		const result = emitSingleSelection(sel, indent, variableNames, schema, parentTypeName);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		lines.push(result.value);
+	}
+	if (inlineFragments.length > 0) {
+		const unionResult = emitInlineFragmentsAsUnion(inlineFragments, indent, variableNames, schema);
+		if (unionResult.isErr()) {
+			return err(unionResult.error);
+		}
+		lines.push(unionResult.value);
+	}
+	return ok(lines.join("\n"));
+};
+/**
+* Emit a single selection (field or fragment spread).
+*/
+const emitSingleSelection = (sel, indent, variableNames, schema, parentTypeName) => {
+	const padding = "  ".repeat(indent);
+	switch (sel.kind) {
+		case "field": return emitFieldSelection(sel, indent, variableNames, schema, parentTypeName);
+		case "fragmentSpread": return ok(`${padding}...${sel.name}Fragment.spread(),`);
+		case "inlineFragment": return ok("");
+	}
+};
+/**
+* Emit inline fragments grouped as a union selection.
+* Format: { TypeA: ({ f }) => ({ ...fields }), TypeB: ({ f }) => ({ ...fields }) }
+*/
+const emitInlineFragmentsAsUnion = (inlineFragments, indent, variableNames, schema) => {
+	const padding = "  ".repeat(indent);
+	for (const frag of inlineFragments) {
+		if (frag.onType === "") {
+			return err({
+				code: "GRAPHQL_INLINE_FRAGMENT_WITHOUT_TYPE",
+				message: "Inline fragments without type condition are not supported. Use `... on TypeName { }` syntax."
+			});
+		}
+	}
+	for (const frag of inlineFragments) {
+		if (schema && !schema.objects.has(frag.onType)) {
+			let isUnionMember = false;
+			for (const [, unionDef] of schema.unions) {
+				if (unionDef.members.has(frag.onType)) {
+					isUnionMember = true;
+					break;
+				}
+			}
+			if (!isUnionMember) {
+				return err({
+					code: "GRAPHQL_INLINE_FRAGMENT_ON_INTERFACE",
+					message: `Inline fragments on interface type "${frag.onType}" are not supported. Use union types instead.`,
+					onType: frag.onType
+				});
+			}
+		}
+	}
+	const entries = [];
+	for (const frag of inlineFragments) {
+		const innerPadding = "  ".repeat(indent + 1);
+		const fieldsResult = emitSelectionsInternal(frag.selections, indent + 2, variableNames, schema, frag.onType);
+		if (fieldsResult.isErr()) {
+			return err(fieldsResult.error);
+		}
+		entries.push(`${innerPadding}${frag.onType}: ({ f }) => ({
+${fieldsResult.value}
+${innerPadding}}),`);
+	}
+	return ok(`${padding}...({
+${entries.join("\n")}
+${padding}}),`);
+};
+/**
+* Emit a single field selection.
+*/
+const emitFieldSelection = (field, indent, variableNames, schema, parentTypeName) => {
+	const padding = "  ".repeat(indent);
+	const args = field.arguments;
+	const selections = field.selections;
+	const hasArgs = args && args.length > 0;
+	const hasSelections = selections && selections.length > 0;
+	if (!hasArgs && !hasSelections) {
+		return ok(`${padding}${field.name}: true,`);
+	}
+	let line = `${padding}...f.${field.name}(`;
+	if (hasArgs) {
+		const argsResult = emitArguments(args, variableNames, schema, parentTypeName, field.name);
+		if (argsResult.isErr()) {
+			return err(argsResult.error);
+		}
+		line += argsResult.value;
+	}
+	line += ")";
+	if (hasSelections) {
+		const hasInlineFragments = selections.some((s) => s.kind === "inlineFragment");
+		const nestedParentType = schema && parentTypeName ? getFieldReturnType(schema, parentTypeName, field.name) ?? undefined : undefined;
+		if (hasInlineFragments) {
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema, nestedParentType);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += "({\n";
+			line += `${nestedResult.value}\n`;
+			line += `${padding}})`;
+		} else {
+			line += "(({ f }) => ({\n";
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema, nestedParentType);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += `${nestedResult.value}\n`;
+			line += `${padding}}))`;
+		}
+	}
+	line += ",";
+	return ok(line);
+};
+/**
+* Check if a modifier represents a list type (contains []).
+*/
+const isListModifier = (modifier) => {
+	return modifier.includes("[]");
+};
+/**
+* Determine if a value needs to be wrapped in an array for list coercion.
+* Returns true if:
+* - Expected type is a list
+* - Value is NOT already a list
+* - Value is NOT a variable (runtime handles coercion)
+* - Value is NOT null
+*/
+const needsListCoercion = (value, expectedModifier) => {
+	if (!expectedModifier) return false;
+	if (!isListModifier(expectedModifier)) return false;
+	if (value.kind === "variable") return false;
+	if (value.kind === "null") return false;
+	if (value.kind === "list") return false;
+	return true;
+};
+/**
+* Extract the element type from a list type by removing the outermost list modifier.
+* For example: "![]!" (non-null list of non-null) → "!" (non-null element)
+*              "?[]![]!" (nested lists) → "?[]!" (inner list type)
+* Returns null if the modifier doesn't represent a list type.
+*/
+const getListElementType = (expectedType) => {
+	const { modifier, typeName } = expectedType;
+	const listMatch = modifier.match(/^(.+?)(\[\][!?])$/);
+	if (!listMatch || !listMatch[1]) return null;
+	return {
+		typeName,
+		modifier: listMatch[1]
+	};
+};
+/**
+* Emit a value with type context for list coercion.
+*/
+const emitValueWithType = (value, expectedType, variableNames, schema) => {
+	const shouldCoerce = needsListCoercion(value, expectedType?.modifier);
+	if (value.kind === "object" && expectedType && schema) {
+		return emitObjectWithType(value, expectedType.typeName, variableNames, schema, shouldCoerce);
+	}
+	if (value.kind === "list" && expectedType && schema) {
+		const elementType = getListElementType(expectedType);
+		if (elementType) {
+			const values = [];
+			for (const v of value.values) {
+				const result$1 = emitValueWithType(v, elementType, variableNames, schema);
+				if (result$1.isErr()) return result$1;
+				values.push(result$1.value);
+			}
+			return ok(`[${values.join(", ")}]`);
+		}
+	}
+	const result = emitValue(value, variableNames);
+	if (result.isErr()) return result;
+	if (shouldCoerce) {
+		return ok(`[${result.value}]`);
+	}
+	return result;
+};
+/**
+* Emit an object value with type context for recursive list coercion.
+*/
+const emitObjectWithType = (value, inputTypeName, variableNames, schema, wrapInArray) => {
+	if (value.fields.length === 0) {
+		return ok(wrapInArray ? "[{}]" : "{}");
+	}
+	const entries = [];
+	for (const f of value.fields) {
+		const fieldType = getInputFieldType(schema, inputTypeName, f.name);
+		if (fieldType === null) {
+			return err({
+				code: "GRAPHQL_UNKNOWN_FIELD",
+				message: `Unknown field "${f.name}" on input type "${inputTypeName}"`,
+				typeName: inputTypeName,
+				fieldName: f.name
+			});
+		}
+		const result = emitValueWithType(f.value, fieldType, variableNames, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		entries.push(`${f.name}: ${result.value}`);
+	}
+	const objectStr = `{ ${entries.join(", ")} }`;
+	return ok(wrapInArray ? `[${objectStr}]` : objectStr);
+};
+/**
+* Emit field arguments with type context for list coercion.
+*/
+const emitArguments = (args, variableNames, schema, parentTypeName, fieldName) => {
+	if (args.length === 0) {
+		return ok("");
+	}
+	const argEntries = [];
+	for (const arg of args) {
+		const expectedType = schema && parentTypeName && fieldName ? getArgumentType(schema, parentTypeName, fieldName, arg.name) : null;
+		const result = emitValueWithType(arg.value, expectedType, variableNames, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		argEntries.push(`${arg.name}: ${result.value}`);
+	}
+	return ok(`{ ${argEntries.join(", ")} }`);
+};
+/**
+* Emit a value (literal or variable reference).
+*/
+const emitValue = (value, variableNames) => {
+	switch (value.kind) {
+		case "variable":
+			if (variableNames.has(value.name)) {
+				return ok(`$.${value.name}`);
+			}
+			return err({
+				code: "GRAPHQL_UNDECLARED_VARIABLE",
+				message: `Variable "$${value.name}" is not declared in the operation`,
+				variableName: value.name
+			});
+		case "int":
+		case "float": return ok(value.value);
+		case "string": return ok(JSON.stringify(value.value));
+		case "boolean": return ok(value.value ? "true" : "false");
+		case "null": return ok("null");
+		case "enum": return ok(JSON.stringify(value.value));
+		case "list": {
+			const values = [];
+			for (const v of value.values) {
+				const result = emitValue(v, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				values.push(result.value);
+			}
+			return ok(`[${values.join(", ")}]`);
+		}
+		case "object": {
+			if (value.fields.length === 0) {
+				return ok("{}");
+			}
+			const entries = [];
+			for (const f of value.fields) {
+				const result = emitValue(f.value, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				entries.push(`${f.name}: ${result.value}`);
+			}
+			return ok(`{ ${entries.join(", ")} }`);
+		}
+	}
+};
+
 //#endregion
 //#region packages/codegen/src/inject-template.ts
 const templateContents = `\
@@ -1549,5 +1715,5 @@ export * from "./_internal";
 };
 
 //#endregion
-export { collectVariableUsages, emitFragment, emitOperation, hashSchema, inferVariablesFromUsages, loadSchema, mergeModifiers, mergeVariableUsages, parseGraphqlFile, parseGraphqlSource, parseTypeNode, runCodegen, sortFragmentsByDependency, transformParsedGraphql, writeInjectTemplate };
+export { collectVariableUsages, emitFragment, emitOperation, getArgumentType, getFieldReturnType, getInputFieldType, hashSchema, inferVariablesFromUsages, isModifierAssignable, loadSchema, mergeModifiers, mergeVariableUsages, parseGraphqlFile, parseGraphqlSource, parseTypeNode, runCodegen, sortFragmentsByDependency, transformParsedGraphql, writeInjectTemplate };
 //# sourceMappingURL=index.mjs.map