@soda-gql/typegen 0.11.25 → 0.12.0

package/dist/index.mjs

@@ -1,11 +1,12 @@
-import { mkdir, writeFile } from "node:fs/promises";
-import { dirname, extname, join, relative, resolve } from "node:path";
-import { builderErrors, createBuilderService, extractFieldSelections, loadSchemasFromBundle } from "@soda-gql/builder";
-import { calculateFieldsType, generateInputObjectType, generateInputType, generateInputTypeFromVarDefs, parseInputSpecifier } from "@soda-gql/core";
+import { writeFile } from "node:fs/promises";
+import { dirname, extname, join, normalize, relative, resolve } from "node:path";
+import { builderErrors, createBuilderService, createGraphqlSystemIdentifyHelper, extractFieldSelections, loadSchemasFromBundle } from "@soda-gql/builder";
+import { buildFieldsFromSelectionSet, calculateFieldsType, createSchemaIndexFromSchema, extractFragmentVariables, generateInputObjectType, generateInputType, generateInputTypeFromVarDefs, parseInputSpecifier, preprocessFragmentArgs } from "@soda-gql/core";
 import { Kind, parse } from "graphql";
 import { err, ok } from "neverthrow";
 import { existsSync, readFileSync } from "node:fs";
-import { build } from "esbuild";
+import fg from "fast-glob";
+import { parseSync } from "@swc/core";
 
 //#region packages/typegen/src/emitter.ts
 /**
@@ -214,7 +215,7 @@ const generateInputObjectTypeDefinitions = (schema, schemaName, inputNames) => {
 			depthOverrides,
 			formatters
 		});
-		lines.push(`type Input_${schemaName}_${inputName} = ${typeString};`);
+		lines.push(`export type Input_${schemaName}_${inputName} = ${typeString};`);
 	}
 	return lines;
 };
@@ -252,8 +253,16 @@ const generateTypesCode = (grouped, schemas, injectsModulePath) => {
 			lines.push(...inputTypeLines);
 			lines.push("");
 		}
-		const fragmentEntries = fragments.sort((a, b) => a.key.localeCompare(b.key)).map((f) => `    readonly "${f.key}": { readonly typename: "${f.typename}"; readonly input: ${f.inputType}; readonly output: ${f.outputType} };`);
-		const operationEntries = operations.sort((a, b) => a.key.localeCompare(b.key)).map((o) => `    readonly "${o.key}": { readonly input: ${o.inputType}; readonly output: ${o.outputType} };`);
+		const deduplicatedFragments = new Map();
+		for (const f of fragments) {
+			deduplicatedFragments.set(f.key, f);
+		}
+		const fragmentEntries = Array.from(deduplicatedFragments.values()).sort((a, b) => a.key.localeCompare(b.key)).map((f) => `    readonly "${f.key}": { readonly typename: "${f.typename}"; readonly input: ${f.inputType}; readonly output: ${f.outputType} };`);
+		const deduplicatedOperations = new Map();
+		for (const o of operations) {
+			deduplicatedOperations.set(o.key, o);
+		}
+		const operationEntries = Array.from(deduplicatedOperations.values()).sort((a, b) => a.key.localeCompare(b.key)).map((o) => `    readonly "${o.key}": { readonly input: ${o.inputType}; readonly output: ${o.outputType} };`);
 		lines.push(`export type PrebuiltTypes_${schemaName} = {`);
 		lines.push("  readonly fragments: {");
 		if (fragmentEntries.length > 0) {
@@ -271,7 +280,7 @@ const generateTypesCode = (grouped, schemas, injectsModulePath) => {
 	return lines.join("\n");
 };
 /**
-* Emit prebuilt types to the prebuilt/types.ts file.
+* Emit prebuilt types to the types.prebuilt.ts file.
 *
 * This function uses a partial failure strategy: if type calculation fails for
 * individual elements (e.g., due to invalid field selections or missing schema
@@ -340,18 +349,6 @@ const typegenErrors = {
 		code: "TYPEGEN_BUILD_FAILED",
 		message,
 		cause
-	}),
-	emitFailed: (path, message, cause) => ({
-		code: "TYPEGEN_EMIT_FAILED",
-		message,
-		path,
-		cause
-	}),
-	bundleFailed: (path, message, cause) => ({
-		code: "TYPEGEN_BUNDLE_FAILED",
-		message,
-		path,
-		cause
 	})
 };
 /**
@@ -368,10 +365,6 @@ const formatTypegenError = (error) => {
 		case "TYPEGEN_SCHEMA_LOAD_FAILED":
 			lines.push(`  Schemas: ${error.schemaNames.join(", ")}`);
 			break;
-		case "TYPEGEN_EMIT_FAILED":
-		case "TYPEGEN_BUNDLE_FAILED":
-			lines.push(`  Path: ${error.path}`);
-			break;
 	}
 	if ("cause" in error && error.cause) {
 		lines.push(`  Caused by: ${error.cause}`);
@@ -380,192 +373,438 @@ const formatTypegenError = (error) => {
 };
 
 //#endregion
-//#region packages/typegen/src/prebuilt-generator.ts
+//#region packages/typegen/src/template-extractor.ts
+const OPERATION_KINDS = new Set([
+	"query",
+	"mutation",
+	"subscription",
+	"fragment"
+]);
+const isOperationKind = (value) => OPERATION_KINDS.has(value);
 /**
-* Generate the prebuilt index module code.
-*
-* Generates index.prebuilt.ts with builder-level type resolution.
-* Types are resolved at the fragment/operation builder level using TKey/TName,
-* eliminating the need for ResolvePrebuiltElement at the composer level.
+* Parse TypeScript source with SWC, returning null on failure.
 */
-const generatePrebuiltModule = (schemas, options) => {
-	const schemaNames = Array.from(schemas.keys());
-	const injection = options.injection ?? new Map();
-	const adapterImports = [];
-	for (const name of schemaNames) {
-		const config = injection.get(name);
-		if (config?.hasAdapter) {
-			adapterImports.push(`adapter_${name}`);
-		}
-	}
-	const internalImports = schemaNames.flatMap((name) => [
-		`__schema_${name}`,
-		`__inputTypeMethods_${name}`,
-		`__directiveMethods_${name}`
-	]);
-	const genericTypes = `
+const safeParseSync = (source, tsx) => {
+	try {
+		return parseSync(source, {
+			syntax: "typescript",
+			tsx,
+			decorators: false,
+			dynamicImport: true
+		});
+	} catch {
+		return null;
+	}
+};
 /**
- * Generic field factory for type-erased field access.
- * Returns a callable for nested field builders. Primitive fields can be spread directly.
- * Runtime behavior differs but spread works for both: ...f.id() and ...f.user()(...)
- */
-type GenericFieldFactory = (
-  ...args: unknown[]
-) => (nest: (tools: GenericFieldsBuilderTools) => AnyFields) => AnyFields;
-
+* Collect gql identifiers from import declarations.
+* Finds imports like `import { gql } from "./graphql-system"`.
+*/
+const collectGqlIdentifiers = (module, filePath, helper) => {
+	const identifiers = new Set();
+	for (const item of module.body) {
+		let declaration = null;
+		if (item.type === "ImportDeclaration") {
+			declaration = item;
+		} else if ("declaration" in item && item.declaration && item.declaration.type === "ImportDeclaration") {
+			declaration = item.declaration;
+		}
+		if (!declaration) {
+			continue;
+		}
+		if (!helper.isGraphqlSystemImportSpecifier({
+			filePath,
+			specifier: declaration.source.value
+		})) {
+			continue;
+		}
+		for (const specifier of declaration.specifiers ?? []) {
+			if (specifier.type === "ImportSpecifier") {
+				const imported = specifier.imported ? specifier.imported.value : specifier.local.value;
+				if (imported === "gql" && !specifier.imported) {
+					identifiers.add(specifier.local.value);
+				}
+			}
+		}
+	}
+	return identifiers;
+};
 /**
- * Generic tools for fields builder callbacks.
- * Uses type-erased factory to allow any field access while maintaining strict mode compatibility.
- */
-type GenericFieldsBuilderTools = {
-  readonly f: Record<string, GenericFieldFactory>;
-  readonly $: Record<string, unknown>;
+* Check if a call expression is a gql.{schemaName}(...) call.
+* Returns the schema name if it is, null otherwise.
+*/
+const getGqlCallSchemaName = (identifiers, call) => {
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression") {
+		return null;
+	}
+	const member = callee;
+	if (member.object.type !== "Identifier" || !identifiers.has(member.object.value)) {
+		return null;
+	}
+	if (member.property.type !== "Identifier") {
+		return null;
+	}
+	const firstArg = call.arguments[0];
+	if (!firstArg?.expression || firstArg.expression.type !== "ArrowFunctionExpression") {
+		return null;
+	}
+	return member.property.value;
 };
-`;
-	const contextTypes = schemaNames.map((name) => `
 /**
- * Resolve fragment types at builder level using TKey.
- * If TKey is a known key in PrebuiltTypes, return resolved types.
- * Otherwise, return PrebuiltEntryNotFound.
- */
-type ResolveFragmentAtBuilder_${name}<
-  TKey extends string | undefined
-> = TKey extends keyof PrebuiltTypes_${name}["fragments"]
-  ? Fragment<
-      PrebuiltTypes_${name}["fragments"][TKey]["typename"],
-      PrebuiltTypes_${name}["fragments"][TKey]["input"] extends infer TInput
-        ? TInput extends void ? void : Partial<TInput & object>
-        : void,
-      Partial<AnyFields>,
-      PrebuiltTypes_${name}["fragments"][TKey]["output"] & object
-    >
-  : TKey extends undefined
-    ? Fragment<"(unknown)", PrebuiltEntryNotFound<"(undefined)", "fragment">, Partial<AnyFields>, PrebuiltEntryNotFound<"(undefined)", "fragment">>
-    : Fragment<"(unknown)", PrebuiltEntryNotFound<TKey & string, "fragment">, Partial<AnyFields>, PrebuiltEntryNotFound<TKey & string, "fragment">>;
-
+* Extract templates from a gql callback's arrow function body.
+* Handles both expression bodies and block bodies with return statements.
+*/
+const extractTemplatesFromCallback = (arrow, schemaName) => {
+	const templates = [];
+	const processExpression = (expr) => {
+		if (expr.type === "TaggedTemplateExpression") {
+			const tagged = expr;
+			extractFromTaggedTemplate(tagged, schemaName, templates);
+			return;
+		}
+		if (expr.type === "CallExpression") {
+			const call = expr;
+			if (call.callee.type === "TaggedTemplateExpression") {
+				extractFromTaggedTemplate(call.callee, schemaName, templates);
+			}
+		}
+	};
+	if (arrow.body.type !== "BlockStatement") {
+		processExpression(arrow.body);
+		return templates;
+	}
+	for (const stmt of arrow.body.stmts) {
+		if (stmt.type === "ReturnStatement" && stmt.argument) {
+			processExpression(stmt.argument);
+		}
+	}
+	return templates;
+};
+const extractFromTaggedTemplate = (tagged, schemaName, templates) => {
+	let kind;
+	let elementName;
+	let typeName;
+	if (tagged.tag.type === "Identifier") {
+		kind = tagged.tag.value;
+	} else if (tagged.tag.type === "CallExpression") {
+		const tagCall = tagged.tag;
+		if (tagCall.callee.type === "Identifier") {
+			kind = tagCall.callee.value;
+		} else {
+			return;
+		}
+		const firstArg = tagCall.arguments[0]?.expression;
+		if (firstArg?.type === "StringLiteral") {
+			elementName = firstArg.value;
+		}
+		const secondArg = tagCall.arguments[1]?.expression;
+		if (secondArg?.type === "StringLiteral") {
+			typeName = secondArg.value;
+		}
+	} else {
+		return;
+	}
+	if (!isOperationKind(kind)) {
+		return;
+	}
+	const { quasis, expressions } = tagged.template;
+	if (tagged.tag.type === "Identifier" && expressions.length > 0) {
+		return;
+	}
+	if (quasis.length === 0) {
+		return;
+	}
+	let content;
+	if (expressions.length === 0) {
+		const quasi = quasis[0];
+		if (!quasi) return;
+		content = quasi.cooked ?? quasi.raw;
+	} else {
+		const parts = [];
+		for (let i = 0; i < quasis.length; i++) {
+			const quasi = quasis[i];
+			if (!quasi) continue;
+			parts.push(quasi.cooked ?? quasi.raw);
+			if (i < expressions.length) {
+				parts.push(`__FRAG_SPREAD_${i}__`);
+			}
+		}
+		content = parts.join("");
+	}
+	templates.push({
+		schemaName,
+		kind,
+		content,
+		...elementName !== undefined ? { elementName } : {},
+		...typeName !== undefined ? { typeName } : {}
+	});
+};
 /**
- * Resolve operation types at builder level using TName.
- */
-type ResolveOperationAtBuilder_${name}<
-  TOperationType extends OperationType,
-  TName extends string
-> = TName extends keyof PrebuiltTypes_${name}["operations"]
-  ? Operation<
-      TOperationType,
-      TName,
-      string[],
-      PrebuiltTypes_${name}["operations"][TName]["input"] & AnyConstAssignableInput,
-      Partial<AnyFields>,
-      PrebuiltTypes_${name}["operations"][TName]["output"] & object
-    >
-  : Operation<
-      TOperationType,
-      TName,
-      string[],
-      PrebuiltEntryNotFound<TName, "operation">,
-      Partial<AnyFields>,
-      PrebuiltEntryNotFound<TName, "operation">
-    >;
-
+* Find the innermost gql call, unwrapping method chains like .attach().
+*/
+const findGqlCall = (identifiers, node) => {
+	if (!node || node.type !== "CallExpression") {
+		return null;
+	}
+	const call = node;
+	if (getGqlCallSchemaName(identifiers, call) !== null) {
+		return call;
+	}
+	const callee = call.callee;
+	if (callee.type !== "MemberExpression") {
+		return null;
+	}
+	return findGqlCall(identifiers, callee.object);
+};
 /**
- * Fragment builder that resolves types at builder level using TKey.
- */
-type PrebuiltFragmentBuilder_${name} = <TKey extends string | undefined = undefined>(
-  options: {
-    key?: TKey;
-    fields: (tools: GenericFieldsBuilderTools) => AnyFields;
-    variables?: Record<string, unknown>;
-    metadata?: unknown;
-  }
-) => ResolveFragmentAtBuilder_${name}<TKey>;
-
+* Walk AST to find gql calls and extract templates.
+*/
+const walkAndExtract = (node, identifiers) => {
+	const templates = [];
+	const visit = (n) => {
+		if (!n || typeof n !== "object") {
+			return;
+		}
+		if ("type" in n && n.type === "CallExpression") {
+			const gqlCall = findGqlCall(identifiers, n);
+			if (gqlCall) {
+				const schemaName = getGqlCallSchemaName(identifiers, gqlCall);
+				if (schemaName) {
+					const arrow = gqlCall.arguments[0]?.expression;
+					templates.push(...extractTemplatesFromCallback(arrow, schemaName));
+				}
+				return;
+			}
+		}
+		if (Array.isArray(n)) {
+			for (const item of n) {
+				visit(item);
+			}
+			return;
+		}
+		for (const key of Object.keys(n)) {
+			if (key === "span" || key === "type") {
+				continue;
+			}
+			const value = n[key];
+			if (value && typeof value === "object") {
+				visit(value);
+			}
+		}
+	};
+	visit(node);
+	return templates;
+};
 /**
- * Operation builder that resolves types at builder level using TName.
- */
-type PrebuiltOperationBuilder_${name}<TOperationType extends OperationType> = <TName extends string>(
-  options: {
-    name: TName;
-    fields: (tools: GenericFieldsBuilderTools) => AnyFields;
-    variables?: Record<string, unknown>;
-    metadata?: unknown;
-  }
-) => ResolveOperationAtBuilder_${name}<TOperationType, TName>;
+* Extract all tagged templates from a TypeScript source file.
+*
+* @param filePath - Absolute path to the source file (used for import resolution)
+* @param source - TypeScript source code
+* @param helper - GraphQL system identifier for resolving gql imports
+* @returns Extracted templates and any warnings
+*/
+const extractTemplatesFromSource = (filePath, source, helper) => {
+	const warnings = [];
+	const isTsx = filePath.endsWith(".tsx");
+	const program = safeParseSync(source, isTsx);
+	if (!program || program.type !== "Module") {
+		if (source.includes("gql")) {
+			warnings.push(`[typegen-extract] Failed to parse ${filePath}`);
+		}
+		return {
+			templates: [],
+			warnings
+		};
+	}
+	const gqlIdentifiers = collectGqlIdentifiers(program, filePath, helper);
+	if (gqlIdentifiers.size === 0) {
+		return {
+			templates: [],
+			warnings
+		};
+	}
+	return {
+		templates: walkAndExtract(program, gqlIdentifiers),
+		warnings
+	};
+};
 
+//#endregion
+//#region packages/typegen/src/template-scanner.ts
 /**
- * Prebuilt context with builder-level type resolution for schema "${name}".
- */
-type PrebuiltContext_${name} = {
-  readonly fragment: { [K: string]: PrebuiltFragmentBuilder_${name} };
-  readonly query: { readonly operation: PrebuiltOperationBuilder_${name}<"query"> };
-  readonly mutation: { readonly operation: PrebuiltOperationBuilder_${name}<"mutation"> };
-  readonly subscription: { readonly operation: PrebuiltOperationBuilder_${name}<"subscription"> };
-  readonly $var: unknown;
-  readonly $dir: StandardDirectives;
-  readonly $colocate: unknown;
-};`).join("\n");
-	const gqlEntries = schemaNames.map((name) => {
-		const config = injection.get(name);
-		const adapterLine = config?.hasAdapter ? `,\n      adapter: adapter_${name}` : "";
-		return `  ${name}: createGqlElementComposer(
-    __schema_${name} as AnyGraphqlSchema,
-    {
-      inputTypeMethods: __inputTypeMethods_${name},
-      directiveMethods: __directiveMethods_${name}${adapterLine}
-    }
-  ) as unknown as GqlComposer_${name}`;
-	});
-	const injectsImportSpecifiers = adapterImports.length > 0 ? adapterImports.join(", ") : "";
-	const injectsImportLine = injectsImportSpecifiers ? `import { ${injectsImportSpecifiers} } from "${options.injectsModulePath}";` : "";
-	const indexCode = `\
+* Source file scanner for tagged template extraction.
+*
+* Discovers source files from config include/exclude patterns,
+* reads them, and extracts tagged templates using the template extractor.
+*
+* @module
+*/
 /**
- * Prebuilt GQL module with builder-level type resolution.
- *
- * Types are resolved at the fragment/operation builder level using TKey/TName,
- * not at the composer level. This enables proper typing for builder arguments
- * and eliminates the need for ResolvePrebuiltElement.
- *
- * @module
- * @generated by @soda-gql/typegen
- */
-
-import {
-  createGqlElementComposer,
-  type AnyConstAssignableInput,
-  type AnyFields,
-  type AnyGraphqlSchema,
-  type Fragment,
-  type Operation,
-  type OperationType,
-  type PrebuiltEntryNotFound,
-  type StandardDirectives,
-} from "@soda-gql/core";
-${injectsImportLine}
-import { ${internalImports.join(", ")} } from "${options.internalModulePath}";
-import type { ${schemaNames.map((name) => `PrebuiltTypes_${name}`).join(", ")} } from "./types.prebuilt";
-${genericTypes}
-${contextTypes}
-
-// Export context types for explicit annotation
-${schemaNames.map((name) => `export type { PrebuiltContext_${name} };`).join("\n")}
-
-// Composer type - TResult already has resolved types from builders, no ResolvePrebuiltElement needed
-${schemaNames.map((name) => `type GqlComposer_${name} = {
-  <TResult>(composeElement: (context: PrebuiltContext_${name}) => TResult): TResult;
-  readonly $schema: AnyGraphqlSchema;
-};`).join("\n")}
+* Scan source files for tagged templates.
+*
+* Uses fast-glob to discover files matching include/exclude patterns,
+* then extracts tagged templates from each file.
+*/
+const scanSourceFiles = (options) => {
+	const { include, exclude, baseDir, helper } = options;
+	const warnings = [];
+	const ignorePatterns = exclude.map((pattern) => pattern.startsWith("!") ? pattern.slice(1) : pattern);
+	const matchedFiles = fg.sync(include, {
+		cwd: baseDir,
+		ignore: ignorePatterns,
+		onlyFiles: true,
+		absolute: true
+	});
+	const templates = new Map();
+	for (const filePath of matchedFiles) {
+		const normalizedPath = normalize(resolve(filePath)).replace(/\\/g, "/");
+		try {
+			const source = readFileSync(normalizedPath, "utf-8");
+			const { templates: extracted, warnings: extractionWarnings } = extractTemplatesFromSource(normalizedPath, source, helper);
+			warnings.push(...extractionWarnings);
+			if (extracted.length > 0) {
+				templates.set(normalizedPath, extracted);
+			}
+		} catch (error) {
+			const message = error instanceof Error ? error.message : String(error);
+			warnings.push(`[typegen-scan] Failed to read ${normalizedPath}: ${message}`);
+		}
+	}
+	return {
+		templates,
+		warnings
+	};
+};
 
+//#endregion
+//#region packages/typegen/src/template-to-selections.ts
+/**
+* Convert extracted templates into field selections for the emitter.
+*
+* @param templates - Templates extracted from source files, keyed by file path
+* @param schemas - Loaded schema objects keyed by schema name
+* @returns Map of canonical IDs to field selection data, plus any warnings
+*/
+const convertTemplatesToSelections = (templates, schemas) => {
+	const selections = new Map();
+	const warnings = [];
+	const schemaIndexes = new Map(Object.entries(schemas).map(([name, schema]) => [name, createSchemaIndexFromSchema(schema)]));
+	for (const [filePath, fileTemplates] of templates) {
+		for (const template of fileTemplates) {
+			const schema = schemas[template.schemaName];
+			if (!schema) {
+				warnings.push(`[typegen-template] Unknown schema "${template.schemaName}" in ${filePath}`);
+				continue;
+			}
+			const schemaIndex = schemaIndexes.get(template.schemaName);
+			if (!schemaIndex) {
+				continue;
+			}
+			try {
+				if (template.kind === "fragment") {
+					const selection = convertFragmentTemplate(template, schema, filePath);
+					if (selection) {
+						selections.set(selection.id, selection.data);
+					}
+				} else {
+					const selection = convertOperationTemplate(template, schema, filePath);
+					if (selection) {
+						selections.set(selection.id, selection.data);
+					}
+				}
+			} catch (error) {
+				const message = error instanceof Error ? error.message : String(error);
+				warnings.push(`[typegen-template] Failed to process ${template.kind} in ${filePath}: ${message}`);
+			}
+		}
+	}
+	return {
+		selections,
+		warnings
+	};
+};
+/**
+* Reconstruct full GraphQL source from an extracted template.
+* For curried syntax (new), prepends the definition header from tag call arguments.
+* For old syntax, returns content as-is.
+*/
+const reconstructGraphql = (template) => {
+	if (template.elementName) {
+		if (template.kind === "fragment" && template.typeName) {
+			return `fragment ${template.elementName} on ${template.typeName} ${template.content}`;
+		}
+		return `${template.kind} ${template.elementName} ${template.content}`;
+	}
+	return template.content;
+};
 /**
- * Prebuilt GQL composers with builder-level type resolution.
- *
- * These composers have the same runtime behavior as the base composers,
- * but their return types are resolved from the prebuilt type registry
- * at the builder level instead of using ResolvePrebuiltElement.
- */
-export const gql: { ${schemaNames.map((name) => `${name}: GqlComposer_${name}`).join("; ")} } = {
-${gqlEntries.join(",\n")}
+* Convert a fragment template into FieldSelectionData.
+*/
+const convertFragmentTemplate = (template, schema, filePath) => {
+	const schemaIndex = createSchemaIndexFromSchema(schema);
+	const graphqlSource = reconstructGraphql(template);
+	const variableDefinitions = extractFragmentVariables(graphqlSource, schemaIndex);
+	const { preprocessed } = preprocessFragmentArgs(graphqlSource);
+	const document = parse(preprocessed);
+	const fragDef = document.definitions.find((d) => d.kind === Kind.FRAGMENT_DEFINITION);
+	if (!fragDef || fragDef.kind !== Kind.FRAGMENT_DEFINITION) {
+		return null;
+	}
+	const fragmentName = fragDef.name.value;
+	const onType = fragDef.typeCondition.name.value;
+	const fields = buildFieldsFromSelectionSet(fragDef.selectionSet, schema, onType);
+	const id = `${filePath}::${fragmentName}`;
+	return {
+		id,
+		data: {
+			type: "fragment",
+			schemaLabel: schema.label,
+			key: fragmentName,
+			typename: onType,
+			fields,
+			variableDefinitions
+		}
+	};
 };
-`;
-	return { indexCode };
+/**
+* Convert an operation template into FieldSelectionData.
+*/
+const convertOperationTemplate = (template, schema, filePath) => {
+	const graphqlSource = reconstructGraphql(template);
+	const document = parse(graphqlSource);
+	const opDef = document.definitions.find((d) => d.kind === Kind.OPERATION_DEFINITION);
+	if (!opDef || opDef.kind !== Kind.OPERATION_DEFINITION) {
+		return null;
+	}
+	const operationName = opDef.name?.value ?? "Anonymous";
+	const operationType = opDef.operation;
+	const rootTypeName = getRootTypeName(schema, operationType);
+	const fields = buildFieldsFromSelectionSet(opDef.selectionSet, schema, rootTypeName);
+	const variableDefinitions = opDef.variableDefinitions ?? [];
+	const id = `${filePath}::${operationName}`;
+	return {
+		id,
+		data: {
+			type: "operation",
+			schemaLabel: schema.label,
+			operationName,
+			operationType,
+			fields,
+			variableDefinitions: [...variableDefinitions]
+		}
+	};
+};
+/**
+* Get the root type name for an operation type from the schema.
+*/
+const getRootTypeName = (schema, operationType) => {
+	switch (operationType) {
+		case "query": return schema.operations.query ?? "Query";
+		case "mutation": return schema.operations.mutation ?? "Mutation";
+		case "subscription": return schema.operations.subscription ?? "Subscription";
+		default: return "Query";
+	}
 };
 
 //#endregion
@@ -575,11 +814,10 @@ ${gqlEntries.join(",\n")}
 *
 * Orchestrates the prebuilt type generation process:
 * 1. Load schemas from generated CJS bundle
-* 2. Generate index.prebuilt.ts
-* 3. Build artifact to evaluate elements
-* 4. Extract field selections
+* 2. Build artifact to evaluate elements
+* 3. Extract field selections from builder
+* 4. Scan source files for tagged templates and merge selections
 * 5. Emit types.prebuilt.ts
-* 6. Bundle prebuilt module
 *
 * @module
 */
@@ -621,58 +859,14 @@ const toImportSpecifier = (fromPath, targetPath, options) => {
 	return `${withoutExt}${runtimeExt}`;
 };
 /**
-* Bundle the prebuilt module to CJS format.
-*/
-const bundlePrebuiltModule = async (sourcePath) => {
-	const sourceExt = extname(sourcePath);
-	const baseName = sourcePath.slice(0, -sourceExt.length);
-	const cjsPath = `${baseName}.cjs`;
-	await build({
-		entryPoints: [sourcePath],
-		outfile: cjsPath,
-		format: "cjs",
-		platform: "node",
-		bundle: true,
-		external: ["@soda-gql/core", "@soda-gql/runtime"],
-		sourcemap: false,
-		minify: false,
-		treeShaking: false
-	});
-	return { cjsPath };
-};
-/**
-* Write a TypeScript module to disk.
-*/
-const writeModule = async (path, content) => {
-	await mkdir(dirname(path), { recursive: true });
-	await writeFile(path, content, "utf-8");
-};
-/**
-* Load GraphQL schema documents from schema paths.
-* This is needed for generatePrebuiltModule which expects DocumentNode.
-*/
-const loadSchemaDocuments = (schemasConfig) => {
-	const documents = new Map();
-	for (const [name, schemaConfig] of Object.entries(schemasConfig)) {
-		const schemaPaths = Array.isArray(schemaConfig.schema) ? schemaConfig.schema : [schemaConfig.schema];
-		let combinedSource = "";
-		for (const schemaPath of schemaPaths) {
-			combinedSource += `${readFileSync(schemaPath, "utf-8")}\n`;
-		}
-		documents.set(name, parse(combinedSource));
-	}
-	return documents;
-};
-/**
 * Run the typegen process.
 *
 * This function:
 * 1. Loads schemas from the generated CJS bundle
-* 2. Generates index.prebuilt.ts using generatePrebuiltModule
-* 3. Creates a BuilderService and builds the artifact
-* 4. Extracts field selections from the artifact
+* 2. Creates a BuilderService and builds the artifact
+* 3. Extracts field selections from the artifact
+* 4. Scans source files for tagged templates and merges selections
 * 5. Emits types.prebuilt.ts using emitPrebuiltTypes
-* 6. Bundles the prebuilt module
 *
 * @param options - Typegen options including config
 * @returns Result containing success data or error
@@ -691,24 +885,8 @@ const runTypegen = async (options) => {
 		return err(typegenErrors.schemaLoadFailed(schemaNames, schemasResult.error));
 	}
 	const schemas = schemasResult.value;
-	const schemaDocuments = loadSchemaDocuments(config.schemas);
-	const prebuiltIndexPath = join(outdir, "index.prebuilt.ts");
-	const internalModulePath = toImportSpecifier(prebuiltIndexPath, join(outdir, "_internal.ts"), importSpecifierOptions);
-	const injectsModulePath = toImportSpecifier(prebuiltIndexPath, join(outdir, "_internal-injects.ts"), importSpecifierOptions);
-	const injection = new Map();
-	for (const [schemaName, schemaConfig] of Object.entries(config.schemas)) {
-		injection.set(schemaName, { hasAdapter: !!schemaConfig.inject.adapter });
-	}
-	const prebuilt = generatePrebuiltModule(schemaDocuments, {
-		internalModulePath,
-		injectsModulePath,
-		injection
-	});
-	try {
-		await writeModule(prebuiltIndexPath, prebuilt.indexCode);
-	} catch (error) {
-		return err(typegenErrors.emitFailed(prebuiltIndexPath, `Failed to write prebuilt index: ${error instanceof Error ? error.message : String(error)}`, error));
-	}
+	const prebuiltTypesPath = join(outdir, "types.prebuilt.ts");
+	const injectsModulePath = toImportSpecifier(prebuiltTypesPath, join(outdir, "_internal-injects.ts"), importSpecifierOptions);
 	const builderService = createBuilderService({ config });
 	const artifactResult = await builderService.buildAsync();
 	if (artifactResult.isErr()) {
@@ -719,7 +897,38 @@ const runTypegen = async (options) => {
 		return err(typegenErrors.buildFailed("No intermediate elements available after build", undefined));
 	}
 	const fieldSelectionsResult = extractFieldSelections(intermediateElements);
-	const { selections: fieldSelections, warnings: extractWarnings } = fieldSelectionsResult;
+	const { selections: builderSelections, warnings: extractWarnings } = fieldSelectionsResult;
+	const graphqlHelper = createGraphqlSystemIdentifyHelper(config);
+	const scanResult = scanSourceFiles({
+		include: [...config.include],
+		exclude: [...config.exclude],
+		baseDir: config.baseDir,
+		helper: graphqlHelper
+	});
+	const templateSelections = convertTemplatesToSelections(scanResult.templates, schemas);
+	const extractFilePart = (id) => {
+		const filePart = id.split("::")[0] ?? "";
+		if (filePart.startsWith("/")) {
+			return relative(config.baseDir, filePart);
+		}
+		return filePart;
+	};
+	const extractElementName = (data) => data.type === "fragment" ? data.key : data.operationName;
+	const templateElements = new Set();
+	for (const [id, data] of templateSelections.selections) {
+		const name = extractElementName(data);
+		if (name) templateElements.add(`${extractFilePart(id)}::${name}`);
+	}
+	const fieldSelections = new Map();
+	for (const [id, data] of builderSelections) {
+		const name = extractElementName(data);
+		if (name && templateElements.has(`${extractFilePart(id)}::${name}`)) continue;
+		fieldSelections.set(id, data);
+	}
+	for (const [id, data] of templateSelections.selections) {
+		fieldSelections.set(id, data);
+	}
+	const scanWarnings = [...scanResult.warnings, ...templateSelections.warnings];
 	const emitResult = await emitPrebuiltTypes({
 		schemas,
 		fieldSelections,
@@ -729,12 +938,7 @@ const runTypegen = async (options) => {
 	if (emitResult.isErr()) {
 		return err(emitResult.error);
 	}
-	const { path: prebuiltTypesPath, warnings: emitWarnings } = emitResult.value;
-	try {
-		await bundlePrebuiltModule(prebuiltIndexPath);
-	} catch (error) {
-		return err(typegenErrors.bundleFailed(prebuiltIndexPath, `Failed to bundle prebuilt module: ${error instanceof Error ? error.message : String(error)}`, error));
-	}
+	const { warnings: emitWarnings } = emitResult.value;
 	let fragmentCount = 0;
 	let operationCount = 0;
 	for (const selection of fieldSelections.values()) {
@@ -744,9 +948,12 @@ const runTypegen = async (options) => {
 			operationCount++;
 		}
 	}
-	const allWarnings = [...extractWarnings, ...emitWarnings];
+	const allWarnings = [
+		...extractWarnings,
+		...scanWarnings,
+		...emitWarnings
+	];
 	return ok({
-		prebuiltIndexPath,
 		prebuiltTypesPath,
 		fragmentCount,
 		operationCount,
@@ -755,5 +962,5 @@ const runTypegen = async (options) => {
 };
 
 //#endregion
-export { emitPrebuiltTypes, formatTypegenError, generatePrebuiltModule, runTypegen, typegenErrors };
+export { emitPrebuiltTypes, formatTypegenError, runTypegen, typegenErrors };
 //# sourceMappingURL=index.mjs.map