@soda-gql/codegen 0.11.18 → 0.11.20

package/dist/index.cjs

@@ -13,16 +13,6 @@ let node_crypto = require("node:crypto");
 const emitOperation = (operation, options) => {
 	const lines = [];
 	const schema = options.schemaDocument ? require_generator.createSchemaIndex(options.schemaDocument) : null;
-	lines.push(`import { gql } from "${options.graphqlSystemPath}";`);
-	if (operation.fragmentDependencies.length > 0 && options.fragmentImports) {
-		for (const fragName of operation.fragmentDependencies) {
-			const importPath = options.fragmentImports.get(fragName);
-			if (importPath) {
-				lines.push(`import { ${fragName}Fragment } from "${importPath}";`);
-			}
-		}
-	}
-	lines.push("");
 	const exportName = `${operation.name}Compat`;
 	const operationType = operation.kind;
 	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${operationType}, $var }) =>`);
@@ -49,16 +39,6 @@ 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) {
-			const importPath = options.fragmentImports.get(fragName);
-			if (importPath) {
-				lines.push(`import { ${fragName}Fragment } from "${importPath}";`);
-			}
-		}
-	}
-	lines.push("");
 	const exportName = `${fragment.name}Fragment`;
 	const destructure = hasVariables ? "fragment, $var" : "fragment";
 	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${destructure} }) =>`);
@@ -190,6 +170,9 @@ const emitFieldSelection = (field, indent, variableNames, schema) => {
 	const selections = field.selections;
 	const hasArgs = args && args.length > 0;
 	const hasSelections = selections && selections.length > 0;
+	if (!hasArgs && !hasSelections) {
+		return (0, neverthrow.ok)(`${padding}${field.name}: true,`);
+	}
 	let line = `${padding}...f.${field.name}(`;
 	if (hasArgs) {
 		const argsResult = emitArguments(args, variableNames);
@@ -586,6 +569,52 @@ const buildModifier = (structure) => {
 	return structure.inner + structure.lists.join("");
 };
 /**
+* Check if source modifier can be assigned to target modifier.
+* Implements GraphQL List Coercion: depth difference of 0 or 1 is allowed.
+*
+* 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
@@ -667,7 +696,8 @@ const collectVariablesFromValue = (value, expectedTypeName, expectedModifier, sc
 		usages.push({
 			name: value.name,
 			typeName: expectedTypeName,
-			modifier: expectedModifier,
+			expectedModifier,
+			minimumModifier: deriveMinimumModifier(expectedModifier),
 			typeKind
 		});
 		return null;
@@ -777,7 +807,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) {
@@ -797,9 +832,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 (0, neverthrow.err)({
 				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
@@ -807,12 +842,21 @@ const mergeVariableUsages = (variableName, usages) => {
 				variableName
 			});
 		}
-		mergedModifier = result.value;
+		candidateModifier = result.value;
+	}
+	for (const usage of usages) {
+		if (!isModifierAssignable(candidateModifier, usage.expectedModifier)) {
+			return (0, neverthrow.err)({
+				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
+				message: `Variable "$${variableName}" with modifier "${candidateModifier}" cannot satisfy expected "${usage.expectedModifier}"`,
+				variableName
+			});
+		}
 	}
 	return (0, neverthrow.ok)({
 		name: variableName,
 		typeName: first.typeName,
-		modifier: mergedModifier,
+		modifier: candidateModifier,
 		typeKind: first.typeKind
 	});
 };
@@ -1008,7 +1052,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);
@@ -1296,6 +1341,23 @@ const generateDefsStructure = (schemaName, categoryVars, chunkSize) => {
 
 //#endregion
 //#region packages/codegen/src/file.ts
+const removeDirectory = (dirPath) => {
+	const targetPath = (0, node_path.resolve)(dirPath);
+	try {
+		(0, node_fs.rmSync)(targetPath, {
+			recursive: true,
+			force: true
+		});
+		return (0, neverthrow.ok)(undefined);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return (0, neverthrow.err)({
+			code: "REMOVE_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
 const writeModule = (outPath, contents) => {
 	const targetPath = (0, node_path.resolve)(outPath);
 	try {
@@ -1492,6 +1554,13 @@ export * from "./_internal";
 	const defsPaths = [];
 	if (categoryVars) {
 		const outDir = (0, node_path.dirname)(outPath);
+		const defsDir = (0, node_path.join)(outDir, "_defs");
+		if ((0, node_fs.existsSync)(defsDir)) {
+			const removeResult = removeDirectory(defsDir);
+			if (removeResult.isErr()) {
+				return (0, neverthrow.err)(removeResult.error);
+			}
+		}
 		const combinedVars = {
 			enums: [],
 			inputs: [],
@@ -1547,6 +1616,7 @@ exports.emitFragment = emitFragment;
 exports.emitOperation = emitOperation;
 exports.hashSchema = hashSchema;
 exports.inferVariablesFromUsages = inferVariablesFromUsages;
+exports.isModifierAssignable = isModifierAssignable;
 exports.loadSchema = loadSchema;
 exports.mergeModifiers = mergeModifiers;
 exports.mergeVariableUsages = mergeVariableUsages;