@soda-gql/codegen 0.11.26 → 0.12.0

package/dist/index.cjs

@@ -1,4 +1,4 @@
-const require_generator = require('./generator-BJX_PNQq.cjs');
+const require_generator = require('./generator-BEFJKQs_.cjs');
 let neverthrow = require("neverthrow");
 let graphql = require("graphql");
 let node_fs = require("node:fs");
@@ -328,6 +328,7 @@ const isModifierAssignable = (source, target) => {
 	for (let i = 0; i < srcStruct.lists.length; i++) {
 		const srcList = srcStruct.lists[i];
 		const tgtList = tgtListsToCompare[i];
+		if (srcList === undefined || tgtList === undefined) break;
 		if (srcList === "[]?" && tgtList === "[]!") return false;
 	}
 	return true;
@@ -372,6 +373,7 @@ const mergeModifiers = (a, b) => {
 	for (let i = 0; i < structA.lists.length; i++) {
 		const listA = structA.lists[i];
 		const listB = structB.lists[i];
+		if (listA === undefined || listB === undefined) break;
 		mergedLists.push(listA === "[]!" || listB === "[]!" ? "[]!" : "[]?");
 	}
 	return {
@@ -550,14 +552,14 @@ const getFieldReturnType = (schema, parentTypeName, fieldName) => {
 * 3. Verify the candidate can satisfy ALL expected modifiers via isModifierAssignable
 */
 const mergeVariableUsages = (variableName, usages) => {
-	if (usages.length === 0) {
+	const first = usages[0];
+	if (!first) {
 		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)({
@@ -569,7 +571,9 @@ const mergeVariableUsages = (variableName, usages) => {
 	}
 	let candidateModifier = first.minimumModifier;
 	for (let i = 1; i < usages.length; i++) {
-		const result = mergeModifiers(candidateModifier, usages[i].minimumModifier);
+		const usage = usages[i];
+		if (!usage) break;
+		const result = mergeModifiers(candidateModifier, usage.minimumModifier);
 		if (!result.ok) {
 			return (0, neverthrow.err)({
 				code: "GRAPHQL_VARIABLE_MODIFIER_INCOMPATIBLE",
@@ -1271,6 +1275,221 @@ const writeInjectTemplate = (outPath) => {
 };
 const getInjectTemplate = () => `${templateContents}\n`;
 
+//#endregion
+//#region packages/codegen/src/reachability.ts
+/**
+* Schema type reachability analysis.
+*
+* Determines which types are reachable from root types (Query/Mutation/Subscription)
+* to specified target types (e.g., fragment onType values from .graphql files).
+* Produces a CompiledFilter for use with existing buildExclusionSet.
+*
+* @module
+*/
+const extractNamedType = (typeNode) => {
+	switch (typeNode.kind) {
+		case graphql.Kind.NAMED_TYPE: return typeNode.name.value;
+		case graphql.Kind.LIST_TYPE: return extractNamedType(typeNode.type);
+		case graphql.Kind.NON_NULL_TYPE: return extractNamedType(typeNode.type);
+	}
+};
+const addEdge = (graph, from, to) => {
+	let edges = graph.get(from);
+	if (!edges) {
+		edges = new Set();
+		graph.set(from, edges);
+	}
+	edges.add(to);
+};
+const buildTypeGraph = (document) => {
+	const schema = require_generator.createSchemaIndex(document);
+	const forward = new Map();
+	const reverse = new Map();
+	const addBidirectional = (from, to) => {
+		addEdge(forward, from, to);
+		addEdge(reverse, to, from);
+	};
+	for (const [typeName, record] of schema.objects) {
+		for (const field of record.fields.values()) {
+			const returnType = extractNamedType(field.type);
+			addBidirectional(typeName, returnType);
+			if (field.arguments) {
+				for (const arg of field.arguments) {
+					const argType = extractNamedType(arg.type);
+					addBidirectional(typeName, argType);
+				}
+			}
+		}
+	}
+	for (const [typeName, record] of schema.inputs) {
+		for (const field of record.fields.values()) {
+			const fieldType = extractNamedType(field.type);
+			addBidirectional(typeName, fieldType);
+		}
+	}
+	for (const [typeName, record] of schema.unions) {
+		for (const memberName of record.members.keys()) {
+			addBidirectional(typeName, memberName);
+		}
+	}
+	return {
+		graph: {
+			forward,
+			reverse
+		},
+		schema
+	};
+};
+/**
+* BFS traversal collecting all reachable nodes from seeds.
+*/
+const bfs = (adjacency, seeds, constraint) => {
+	const visited = new Set();
+	const queue = [];
+	for (const seed of seeds) {
+		if (!visited.has(seed)) {
+			visited.add(seed);
+			queue.push(seed);
+		}
+	}
+	let head = 0;
+	while (head < queue.length) {
+		const current = queue[head++];
+		if (current === undefined) break;
+		const neighbors = adjacency.get(current);
+		if (!neighbors) continue;
+		for (const neighbor of neighbors) {
+			if (visited.has(neighbor)) continue;
+			if (constraint && !constraint.has(neighbor)) continue;
+			visited.add(neighbor);
+			queue.push(neighbor);
+		}
+	}
+	return visited;
+};
+/**
+* Compute the set of type names reachable on paths from root types to target types.
+*
+* Algorithm:
+* 1. Backward BFS from target types to find all upstream types
+* 2. Forward BFS from root types, constrained to upstream set, to find actual paths
+* 3. Collect input/enum/scalar types used as field arguments on reachable object types
+*/
+const computeReachableTypes = (graph, schema, targetTypes, usedArgumentTypes) => {
+	const upstream = bfs(graph.reverse, targetTypes);
+	const rootTypes = [];
+	if (schema.operationTypes.query) rootTypes.push(schema.operationTypes.query);
+	if (schema.operationTypes.mutation) rootTypes.push(schema.operationTypes.mutation);
+	if (schema.operationTypes.subscription) rootTypes.push(schema.operationTypes.subscription);
+	const validRoots = rootTypes.filter((r) => upstream.has(r));
+	const pathTypes = bfs(graph.forward, validRoots, upstream);
+	const reachable = new Set(pathTypes);
+	const inputQueue = [];
+	for (const typeName of pathTypes) {
+		const objectRecord = schema.objects.get(typeName);
+		if (!objectRecord) continue;
+		for (const field of objectRecord.fields.values()) {
+			const returnType = extractNamedType(field.type);
+			if (!reachable.has(returnType)) {
+				const isKnownComposite = schema.objects.has(returnType) || schema.inputs.has(returnType) || schema.unions.has(returnType);
+				if (!isKnownComposite) {
+					reachable.add(returnType);
+				}
+			}
+			if (!usedArgumentTypes && field.arguments) {
+				for (const arg of field.arguments) {
+					const argType = extractNamedType(arg.type);
+					if (!reachable.has(argType)) {
+						reachable.add(argType);
+						if (schema.inputs.has(argType)) {
+							inputQueue.push(argType);
+						}
+					}
+				}
+			}
+		}
+	}
+	if (usedArgumentTypes) {
+		for (const inputName of usedArgumentTypes) {
+			if (!reachable.has(inputName)) {
+				reachable.add(inputName);
+				inputQueue.push(inputName);
+			}
+		}
+	}
+	let inputHead = 0;
+	while (inputHead < inputQueue.length) {
+		const inputName = inputQueue[inputHead++];
+		if (inputName === undefined) break;
+		const inputRecord = schema.inputs.get(inputName);
+		if (!inputRecord) continue;
+		for (const field of inputRecord.fields.values()) {
+			const fieldType = extractNamedType(field.type);
+			if (!reachable.has(fieldType)) {
+				reachable.add(fieldType);
+				if (schema.inputs.has(fieldType)) {
+					inputQueue.push(fieldType);
+				}
+			}
+		}
+	}
+	return reachable;
+};
+/**
+* Compute a filter function that includes only types reachable from root types
+* to the specified target types.
+*
+* When targetTypes is empty, returns a pass-all filter (no filtering).
+* Warns when target types are not found in the schema.
+*
+* @param document - The parsed GraphQL schema document
+* @param targetTypes - Set of type names that fragments target (e.g., from ParsedFragment.onType)
+* @returns Filter function and any warnings
+*/
+const computeReachabilityFilter = (document, targetTypes, usedArgumentTypes) => {
+	if (targetTypes.size === 0) {
+		return {
+			filter: () => true,
+			warnings: []
+		};
+	}
+	const { graph, schema } = buildTypeGraph(document);
+	const allTypeNames = new Set([
+		...schema.objects.keys(),
+		...schema.inputs.keys(),
+		...schema.enums.keys(),
+		...schema.unions.keys(),
+		...schema.scalars.keys()
+	]);
+	const warnings = [];
+	const validTargets = new Set();
+	for (const target of targetTypes) {
+		if (allTypeNames.has(target)) {
+			validTargets.add(target);
+		} else {
+			warnings.push(`Target type "${target}" not found in schema`);
+		}
+	}
+	if (validTargets.size === 0) {
+		return {
+			filter: () => true,
+			warnings
+		};
+	}
+	const reachable = computeReachableTypes(graph, schema, validTargets, usedArgumentTypes);
+	if (reachable.size === 0) {
+		warnings.push(`No types reachable from root operations to target types: ${[...validTargets].join(", ")}; skipping reachability filter`);
+		return {
+			filter: () => true,
+			warnings
+		};
+	}
+	return {
+		filter: (context) => reachable.has(context.name),
+		warnings
+	};
+};
+
 //#endregion
 //#region packages/codegen/src/bundler/esbuild.ts
 const esbuildBundler = {
@@ -1485,6 +1704,20 @@ const removeDirectory = (dirPath) => {
 		});
 	}
 };
+const readModule = (filePath) => {
+	const targetPath = (0, node_path.resolve)(filePath);
+	try {
+		const content = (0, node_fs.readFileSync)(targetPath, "utf-8");
+		return (0, neverthrow.ok)(content);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return (0, neverthrow.err)({
+			code: "READ_FAILED",
+			message,
+			outPath: targetPath
+		});
+	}
+};
 const writeModule = (outPath, contents) => {
 	const targetPath = (0, node_path.resolve)(outPath);
 	try {
@@ -1612,11 +1845,16 @@ const runCodegen = async (options) => {
 	const schemas = new Map();
 	const schemaHashes = {};
 	for (const [name, schemaConfig] of Object.entries(options.schemas)) {
-		const result = await loadSchema(schemaConfig.schema).match((doc) => Promise.resolve((0, neverthrow.ok)(doc)), (error) => Promise.resolve((0, neverthrow.err)(error)));
-		if (result.isErr()) {
-			return (0, neverthrow.err)(result.error);
+		const preloaded = options.preloadedSchemas?.get(name);
+		if (preloaded) {
+			schemas.set(name, preloaded);
+		} else {
+			const result = await loadSchema(schemaConfig.schema).match((doc) => Promise.resolve((0, neverthrow.ok)(doc)), (error) => Promise.resolve((0, neverthrow.err)(error)));
+			if (result.isErr()) {
+				return (0, neverthrow.err)(result.error);
+			}
+			schemas.set(name, result.value);
 		}
-		schemas.set(name, result.value);
 	}
 	const injectionConfig = new Map();
 	for (const [schemaName, schemaConfig] of Object.entries(options.schemas)) {
@@ -1650,15 +1888,10 @@ const runCodegen = async (options) => {
 		chunkSize,
 		typeFilters: typeFiltersConfig.size > 0 ? typeFiltersConfig : undefined
 	});
-	const indexCode = `/**
- * Generated by @soda-gql/codegen
- * @module
- * @generated
- */
-export * from "./_internal";
-`;
+	const schemaNames = Object.keys(options.schemas);
+	const indexCode = require_generator.generateIndexModule(schemaNames);
 	for (const [name, document] of schemas.entries()) {
-		const schemaIndex = (await Promise.resolve().then(() => require("./generator-C2g1EDwR.cjs"))).createSchemaIndex(document);
+		const schemaIndex = (await Promise.resolve().then(() => require("./generator-C_BtU_dR.cjs"))).createSchemaIndex(document);
 		const objects = Array.from(schemaIndex.objects.keys()).filter((n) => !n.startsWith("__")).length;
 		const enums = Array.from(schemaIndex.enums.keys()).filter((n) => !n.startsWith("__")).length;
 		const inputs = Array.from(schemaIndex.inputs.keys()).filter((n) => !n.startsWith("__")).length;
@@ -1719,6 +1952,35 @@ export * from "./_internal";
 	if (indexWriteResult.isErr()) {
 		return (0, neverthrow.err)(indexWriteResult.error);
 	}
+	const prebuiltStubPath = (0, node_path.join)((0, node_path.dirname)(outPath), "types.prebuilt.ts");
+	if (!(0, node_fs.existsSync)(prebuiltStubPath)) {
+		const prebuiltStubCode = require_generator.generatePrebuiltStub(schemaNames);
+		const prebuiltWriteResult = await writeModule(prebuiltStubPath, prebuiltStubCode).match(() => Promise.resolve((0, neverthrow.ok)(undefined)), (error) => Promise.resolve((0, neverthrow.err)(error)));
+		if (prebuiltWriteResult.isErr()) {
+			return (0, neverthrow.err)(prebuiltWriteResult.error);
+		}
+	} else {
+		const readResult = readModule(prebuiltStubPath);
+		if (readResult.isErr()) {
+			return (0, neverthrow.err)(readResult.error);
+		}
+		const existingContent = readResult.value;
+		const existingNames = new Set();
+		for (const match of existingContent.matchAll(/export type PrebuiltTypes_(\w+)/g)) {
+			const name = match[1];
+			if (name) existingNames.add(name);
+		}
+		const missingNames = schemaNames.filter((name) => !existingNames.has(name));
+		if (missingNames.length > 0) {
+			const missingStubs = require_generator.generatePrebuiltStub(missingNames);
+			const stubDeclarations = missingStubs.replace(/^\/\*\*[\s\S]*?\*\/\n\n/, "");
+			const updatedContent = `${existingContent.trimEnd()}\n\n${stubDeclarations}`;
+			const patchResult = writeModule(prebuiltStubPath, updatedContent);
+			if (patchResult.isErr()) {
+				return (0, neverthrow.err)(patchResult.error);
+			}
+		}
+	}
 	const bundleOutcome = await esbuildBundler.bundle({
 		sourcePath: outPath,
 		external: ["@soda-gql/core", "@soda-gql/runtime"]
@@ -1739,6 +2001,8 @@ export * from "./_internal";
 
 //#endregion
 exports.collectVariableUsages = collectVariableUsages;
+exports.compileTypeFilter = require_generator.compileTypeFilter;
+exports.computeReachabilityFilter = computeReachabilityFilter;
 exports.emitFragment = emitFragment;
 exports.emitOperation = emitOperation;
 exports.getArgumentType = getArgumentType;