@soda-gql/codegen 0.11.16 → 0.11.18

package/dist/index.cjs

@@ -48,6 +48,7 @@ const emitOperation = (operation, options) => {
 const emitFragment = (fragment, options) => {
 	const lines = [];
 	const schema = options.schemaDocument ? require_generator.createSchemaIndex(options.schemaDocument) : null;
+	const hasVariables = fragment.variables.length > 0;
 	lines.push(`import { gql } from "${options.graphqlSystemPath}";`);
 	if (fragment.fragmentDependencies.length > 0 && options.fragmentImports) {
 		for (const fragName of fragment.fragmentDependencies) {
@@ -59,10 +60,15 @@ const emitFragment = (fragment, options) => {
 	}
 	lines.push("");
 	const exportName = `${fragment.name}Fragment`;
-	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ fragment }) =>`);
+	const destructure = hasVariables ? "fragment, $var" : "fragment";
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${destructure} }) =>`);
 	lines.push(`  fragment.${fragment.onType}({`);
-	lines.push(`    fields: ({ f }) => ({`);
-	const fieldLinesResult = emitSelections(fragment.selections, 3, [], schema);
+	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 (0, neverthrow.err)(fieldLinesResult.error);
 	}
@@ -80,7 +86,7 @@ const emitVariables = (variables) => {
 };
 /**
 * Emit field selections (public API).
-* Converts EnrichedVariable[] to Set<string> and delegates to internal implementation.
+* 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));
@@ -556,36 +562,399 @@ const builtinScalarTypes = new Set([
 	"Boolean"
 ]);
 /**
+* Parse a modifier string into its structural components.
+* @param modifier - Modifier string like "!", "?", "![]!", "?[]?[]!"
+* @returns Parsed structure with inner nullability and list modifiers
+*/
+const parseModifierStructure = (modifier) => {
+	const inner = modifier[0] === "!" ? "!" : "?";
+	const lists = [];
+	const listPattern = /\[\]([!?])/g;
+	let match;
+	while ((match = listPattern.exec(modifier)) !== null) {
+		lists.push(`[]${match[1]}`);
+	}
+	return {
+		inner,
+		lists
+	};
+};
+/**
+* Rebuild modifier string from structure.
+*/
+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
+*
+* @param a - First modifier
+* @param b - Second modifier
+* @returns Merged modifier or error if incompatible
+*/
+const mergeModifiers = (a, b) => {
+	const structA = parseModifierStructure(a);
+	const structB = parseModifierStructure(b);
+	if (structA.lists.length !== structB.lists.length) {
+		return {
+			ok: false,
+			reason: `Incompatible list depths: "${a}" has ${structA.lists.length} list level(s), "${b}" has ${structB.lists.length}`
+		};
+	}
+	const mergedInner = structA.inner === "!" || structB.inner === "!" ? "!" : "?";
+	const mergedLists = [];
+	for (let i = 0; i < structA.lists.length; i++) {
+		const listA = structA.lists[i];
+		const listB = structB.lists[i];
+		mergedLists.push(listA === "[]!" || listB === "[]!" ? "[]!" : "[]?");
+	}
+	return {
+		ok: true,
+		value: buildModifier({
+			inner: mergedInner,
+			lists: mergedLists
+		})
+	};
+};
+/**
+* Get the expected type for a field argument from the schema.
+* Returns null if the field or argument is not found.
+*/
+const getArgumentType = (schema, parentTypeName, fieldName, argumentName) => {
+	const objectRecord = schema.objects.get(parentTypeName);
+	if (!objectRecord) return null;
+	const fieldDef = objectRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	const argDef = fieldDef.arguments?.find((arg) => arg.name.value === argumentName);
+	if (!argDef) return null;
+	return parseTypeNode(argDef.type);
+};
+/**
+* Get the expected type for an input object field from the schema.
+*/
+const getInputFieldType = (schema, inputTypeName, fieldName) => {
+	const inputRecord = schema.inputs.get(inputTypeName);
+	if (!inputRecord) return null;
+	const fieldDef = inputRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	return parseTypeNode(fieldDef.type);
+};
+/**
+* Resolve the type kind for a type name.
+*/
+const resolveTypeKindFromName = (schema, typeName) => {
+	if (isScalarName(schema, typeName)) return "scalar";
+	if (isEnumName(schema, typeName)) return "enum";
+	if (schema.inputs.has(typeName)) return "input";
+	return null;
+};
+/**
+* Extract variable usages from a parsed value, given the expected type.
+* Handles nested input objects recursively.
+*/
+const collectVariablesFromValue = (value, expectedTypeName, expectedModifier, schema, usages) => {
+	if (value.kind === "variable") {
+		const typeKind = resolveTypeKindFromName(schema, expectedTypeName);
+		if (!typeKind) {
+			return {
+				code: "GRAPHQL_UNKNOWN_TYPE",
+				message: `Unknown type "${expectedTypeName}" for variable "$${value.name}"`,
+				typeName: expectedTypeName
+			};
+		}
+		usages.push({
+			name: value.name,
+			typeName: expectedTypeName,
+			modifier: expectedModifier,
+			typeKind
+		});
+		return null;
+	}
+	if (value.kind === "object") {
+		for (const field of value.fields) {
+			const fieldType = getInputFieldType(schema, expectedTypeName, field.name);
+			if (!fieldType) {
+				return {
+					code: "GRAPHQL_UNKNOWN_FIELD",
+					message: `Unknown field "${field.name}" on input type "${expectedTypeName}"`,
+					typeName: expectedTypeName,
+					fieldName: field.name
+				};
+			}
+			const error = collectVariablesFromValue(field.value, fieldType.typeName, fieldType.modifier, schema, usages);
+			if (error) return error;
+		}
+		return null;
+	}
+	if (value.kind === "list") {
+		const struct = parseModifierStructure(expectedModifier);
+		if (struct.lists.length > 0) {
+			const innerModifier = buildModifier({
+				inner: struct.inner,
+				lists: struct.lists.slice(1)
+			});
+			for (const item of value.values) {
+				const error = collectVariablesFromValue(item, expectedTypeName, innerModifier, schema, usages);
+				if (error) return error;
+			}
+		}
+	}
+	return null;
+};
+/**
+* Collect variable usages from field arguments.
+*/
+const collectVariablesFromArguments = (args, parentTypeName, fieldName, schema, usages) => {
+	for (const arg of args) {
+		const argType = getArgumentType(schema, parentTypeName, fieldName, arg.name);
+		if (!argType) {
+			return {
+				code: "GRAPHQL_UNKNOWN_ARGUMENT",
+				message: `Unknown argument "${arg.name}" on field "${fieldName}"`,
+				fieldName,
+				argumentName: arg.name
+			};
+		}
+		const error = collectVariablesFromValue(arg.value, argType.typeName, argType.modifier, schema, usages);
+		if (error) return error;
+	}
+	return null;
+};
+/**
+* Recursively collect all variable usages from selections.
+*/
+const collectVariableUsages = (selections, parentTypeName, schema) => {
+	const usages = [];
+	const collect = (sels, parentType) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "field": {
+					if (sel.arguments && sel.arguments.length > 0) {
+						const error$1 = collectVariablesFromArguments(sel.arguments, parentType, sel.name, schema, usages);
+						if (error$1) return error$1;
+					}
+					if (sel.selections && sel.selections.length > 0) {
+						const fieldReturnType = getFieldReturnType(schema, parentType, sel.name);
+						if (!fieldReturnType) {
+							return {
+								code: "GRAPHQL_UNKNOWN_FIELD",
+								message: `Unknown field "${sel.name}" on type "${parentType}"`,
+								typeName: parentType,
+								fieldName: sel.name
+							};
+						}
+						const error$1 = collect(sel.selections, fieldReturnType);
+						if (error$1) return error$1;
+					}
+					break;
+				}
+				case "inlineFragment": {
+					const error$1 = collect(sel.selections, sel.onType);
+					if (error$1) return error$1;
+					break;
+				}
+				case "fragmentSpread": break;
+			}
+		}
+		return null;
+	};
+	const error = collect(selections, parentTypeName);
+	if (error) return (0, neverthrow.err)(error);
+	return (0, neverthrow.ok)(usages);
+};
+/**
+* Get the return type of a field (unwrapped from modifiers).
+*/
+const getFieldReturnType = (schema, parentTypeName, fieldName) => {
+	const objectRecord = schema.objects.get(parentTypeName);
+	if (!objectRecord) return null;
+	const fieldDef = objectRecord.fields.get(fieldName);
+	if (!fieldDef) return null;
+	const { typeName } = parseTypeNode(fieldDef.type);
+	return typeName;
+};
+/**
+* Merge multiple variable usages into a single InferredVariable.
+* Validates type compatibility and merges modifiers using stricter constraint.
+*/
+const mergeVariableUsages = (variableName, usages) => {
+	if (usages.length === 0) {
+		return (0, neverthrow.err)({
+			code: "GRAPHQL_UNDECLARED_VARIABLE",
+			message: `No usages found for variable "${variableName}"`,
+			variableName
+		});
+	}
+	const first = usages[0];
+	for (const usage of usages) {
+		if (usage.typeName !== first.typeName) {
+			return (0, neverthrow.err)({
+				code: "GRAPHQL_VARIABLE_TYPE_MISMATCH",
+				message: `Variable "$${variableName}" has conflicting types: "${first.typeName}" and "${usage.typeName}"`,
+				variableName
+			});
+		}
+	}
+	let mergedModifier = first.modifier;
+	for (let i = 1; i < usages.length; i++) {
+		const result = mergeModifiers(mergedModifier, usages[i].modifier);
+		if (!result.ok) {
+			return (0, neverthrow.err)({
+				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
+				message: `Variable "$${variableName}" has incompatible modifiers: ${result.reason}`,
+				variableName
+			});
+		}
+		mergedModifier = result.value;
+	}
+	return (0, neverthrow.ok)({
+		name: variableName,
+		typeName: first.typeName,
+		modifier: mergedModifier,
+		typeKind: first.typeKind
+	});
+};
+/**
+* Infer variables from collected usages.
+* Groups by variable name and merges each group.
+*/
+const inferVariablesFromUsages = (usages) => {
+	const byName = new Map();
+	for (const usage of usages) {
+		const existing = byName.get(usage.name);
+		if (existing) {
+			existing.push(usage);
+		} else {
+			byName.set(usage.name, [usage]);
+		}
+	}
+	const variables = [];
+	for (const [name, group] of byName) {
+		const result = mergeVariableUsages(name, group);
+		if (result.isErr()) return (0, neverthrow.err)(result.error);
+		variables.push(result.value);
+	}
+	variables.sort((a, b) => a.name.localeCompare(b.name));
+	return (0, neverthrow.ok)(variables);
+};
+/**
 * Check if a type name is a scalar type.
 */
 const isScalarName = (schema, name) => builtinScalarTypes.has(name) || schema.scalars.has(name);
 /**
+* Topologically sort fragments so dependencies come before dependents.
+* Detects circular dependencies.
+*
+* Note: Uses the existing collectFragmentDependencies function defined below.
+*/
+const sortFragmentsByDependency = (fragments) => {
+	const graph = new Map();
+	for (const fragment of fragments) {
+		const deps = collectFragmentDependenciesSet(fragment.selections);
+		graph.set(fragment.name, deps);
+	}
+	const fragmentByName = new Map();
+	for (const f of fragments) {
+		fragmentByName.set(f.name, f);
+	}
+	const sorted = [];
+	const visited = new Set();
+	const visiting = new Set();
+	const visit = (name, path) => {
+		if (visited.has(name)) return null;
+		if (visiting.has(name)) {
+			const cycleStart = path.indexOf(name);
+			const cycle = path.slice(cycleStart).concat(name);
+			return {
+				code: "GRAPHQL_FRAGMENT_CIRCULAR_DEPENDENCY",
+				message: `Circular dependency detected in fragments: ${cycle.join(" -> ")}`,
+				fragmentNames: cycle
+			};
+		}
+		const fragment = fragmentByName.get(name);
+		if (!fragment) {
+			visited.add(name);
+			return null;
+		}
+		visiting.add(name);
+		const deps = graph.get(name) ?? new Set();
+		for (const dep of deps) {
+			const error = visit(dep, [...path, name]);
+			if (error) return error;
+		}
+		visiting.delete(name);
+		visited.add(name);
+		sorted.push(fragment);
+		return null;
+	};
+	for (const fragment of fragments) {
+		const error = visit(fragment.name, []);
+		if (error) return (0, neverthrow.err)(error);
+	}
+	return (0, neverthrow.ok)(sorted);
+};
+/**
+* Recursively collect fragment spread names from selections into a Set.
+* Internal helper for sortFragmentsByDependency.
+*/
+const collectFragmentDependenciesSet = (selections) => {
+	const deps = new Set();
+	const collect = (sels) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "fragmentSpread":
+					deps.add(sel.name);
+					break;
+				case "field":
+					if (sel.selections) {
+						collect(sel.selections);
+					}
+					break;
+				case "inlineFragment":
+					collect(sel.selections);
+					break;
+			}
+		}
+	};
+	collect(selections);
+	return deps;
+};
+/**
 * Check if a type name is an enum type.
 */
 const isEnumName = (schema, name) => schema.enums.has(name);
 /**
 * Transform parsed operations/fragments by enriching them with schema information.
 *
-* This resolves variable type kinds (scalar, enum, input) and collects
-* fragment dependencies.
+* This resolves variable type kinds (scalar, enum, input), collects
+* fragment dependencies, and infers variables for fragments.
 */
 const transformParsedGraphql = (parsed, options) => {
 	const schema = require_generator.createSchemaIndex(options.schemaDocument);
-	const operations = [];
-	for (const op of parsed.operations) {
-		const result = transformOperation(op, schema);
+	const sortResult = sortFragmentsByDependency(parsed.fragments);
+	if (sortResult.isErr()) {
+		return (0, neverthrow.err)(sortResult.error);
+	}
+	const sortedFragments = sortResult.value;
+	const resolvedFragmentVariables = new Map();
+	const fragments = [];
+	for (const frag of sortedFragments) {
+		const result = transformFragment(frag, schema, resolvedFragmentVariables);
 		if (result.isErr()) {
 			return (0, neverthrow.err)(result.error);
 		}
-		operations.push(result.value);
+		resolvedFragmentVariables.set(frag.name, result.value.variables);
+		fragments.push(result.value);
 	}
-	const fragments = [];
-	for (const frag of parsed.fragments) {
-		const result = transformFragment(frag, schema);
+	const operations = [];
+	for (const op of parsed.operations) {
+		const result = transformOperation(op, schema);
 		if (result.isErr()) {
 			return (0, neverthrow.err)(result.error);
 		}
-		fragments.push(result.value);
+		operations.push(result.value);
 	}
 	return (0, neverthrow.ok)({
 		operations,
@@ -620,12 +989,36 @@ const transformOperation = (op, schema) => {
 };
 /**
 * Transform a single fragment.
+* Infers variables from field arguments and propagates variables from spread fragments.
 */
-const transformFragment = (frag, _schema) => {
+const transformFragment = (frag, schema, resolvedFragmentVariables) => {
 	const fragmentDependencies = collectFragmentDependencies(frag.selections);
+	const directUsagesResult = collectVariableUsages(frag.selections, frag.onType, schema);
+	if (directUsagesResult.isErr()) {
+		return (0, neverthrow.err)(directUsagesResult.error);
+	}
+	const directUsages = directUsagesResult.value;
+	const spreadVariables = [];
+	for (const depName of fragmentDependencies) {
+		const depVariables = resolvedFragmentVariables.get(depName);
+		if (depVariables) {
+			spreadVariables.push(...depVariables);
+		}
+	}
+	const allUsages = [...directUsages, ...spreadVariables.map((v) => ({
+		name: v.name,
+		typeName: v.typeName,
+		modifier: v.modifier,
+		typeKind: v.typeKind
+	}))];
+	const variablesResult = inferVariablesFromUsages(allUsages);
+	if (variablesResult.isErr()) {
+		return (0, neverthrow.err)(variablesResult.error);
+	}
 	return (0, neverthrow.ok)({
 		...frag,
-		fragmentDependencies
+		fragmentDependencies,
+		variables: variablesResult.value
 	});
 };
 /**
@@ -1149,14 +1542,19 @@ export * from "./_internal";
 };
 
 //#endregion
+exports.collectVariableUsages = collectVariableUsages;
 exports.emitFragment = emitFragment;
 exports.emitOperation = emitOperation;
 exports.hashSchema = hashSchema;
+exports.inferVariablesFromUsages = inferVariablesFromUsages;
 exports.loadSchema = loadSchema;
+exports.mergeModifiers = mergeModifiers;
+exports.mergeVariableUsages = mergeVariableUsages;
 exports.parseGraphqlFile = parseGraphqlFile;
 exports.parseGraphqlSource = parseGraphqlSource;
 exports.parseTypeNode = parseTypeNode;
 exports.runCodegen = runCodegen;
+exports.sortFragmentsByDependency = sortFragmentsByDependency;
 exports.transformParsedGraphql = transformParsedGraphql;
 exports.writeInjectTemplate = writeInjectTemplate;
 //# sourceMappingURL=index.cjs.map