@soda-gql/typegen 0.10.1

package/dist/index.cjs

@@ -0,0 +1,652 @@
+let node_fs_promises = require("node:fs/promises");
+let node_path = require("node:path");
+let __soda_gql_builder = require("@soda-gql/builder");
+let __soda_gql_core = require("@soda-gql/core");
+let graphql = require("graphql");
+let neverthrow = require("neverthrow");
+let node_fs = require("node:fs");
+let esbuild = require("esbuild");
+
+//#region packages/typegen/src/emitter.ts
+/**
+* Prebuilt types emitter.
+*
+* Generates TypeScript type definitions for PrebuiltTypes registry
+* from field selection data and schema.
+*
+* ## Error Handling Strategy
+*
+* The emitter uses a partial failure approach for type calculation errors:
+*
+* **Recoverable errors** (result in warnings, element skipped):
+* - Type calculation failures (e.g., `calculateFieldsType` throws)
+* - Input type generation failures (e.g., `generateInputType` throws)
+* - These are caught per-element, logged as warnings, and the element is omitted
+*
+* **Fatal errors** (result in error result):
+* - `SCHEMA_NOT_FOUND`: Selection references non-existent schema
+* - `WRITE_FAILED`: Cannot write output file to disk
+*
+* This allows builds to succeed with partial type coverage when some elements
+* have issues, while providing visibility into problems via warnings.
+*
+* @module
+*/
+/**
+* Group field selections by schema.
+* Uses the schemaLabel from each selection to group them correctly.
+*
+* @returns Result containing grouped selections and warnings, or error if schema not found
+*/
+const groupBySchema = (fieldSelections, schemas) => {
+	const grouped = new Map();
+	const warnings = [];
+	for (const schemaName of Object.keys(schemas)) {
+		grouped.set(schemaName, {
+			fragments: [],
+			operations: [],
+			inputObjects: new Set()
+		});
+	}
+	for (const [canonicalId, selection] of fieldSelections) {
+		const schemaName = selection.schemaLabel;
+		const schema = schemas[schemaName];
+		const group = grouped.get(schemaName);
+		if (!schema || !group) {
+			return (0, neverthrow.err)(__soda_gql_builder.builderErrors.schemaNotFound(schemaName, canonicalId));
+		}
+		const outputFormatters = { scalarOutput: (name) => `ScalarOutput_${schemaName}<"${name}">` };
+		const inputFormatters = {
+			scalarInput: (name) => `ScalarInput_${schemaName}<"${name}">`,
+			inputObject: (name) => `Input_${schemaName}_${name}`
+		};
+		if (selection.type === "fragment") {
+			if (!selection.key) {
+				continue;
+			}
+			try {
+				const usedInputObjects = collectUsedInputObjectsFromSpecifiers(schema, selection.variableDefinitions);
+				for (const inputName of usedInputObjects) {
+					group.inputObjects.add(inputName);
+				}
+				const outputType = (0, __soda_gql_core.calculateFieldsType)(schema, selection.fields, outputFormatters);
+				const hasVariables = Object.keys(selection.variableDefinitions).length > 0;
+				const inputType = hasVariables ? (0, __soda_gql_core.generateInputTypeFromSpecifiers)(schema, selection.variableDefinitions, { formatters: inputFormatters }) : "void";
+				group.fragments.push({
+					key: selection.key,
+					inputType,
+					outputType
+				});
+			} catch (error) {
+				warnings.push(`[prebuilt] Failed to calculate type for fragment "${selection.key}": ${error instanceof Error ? error.message : String(error)}`);
+			}
+		} else if (selection.type === "operation") {
+			try {
+				const usedInputObjects = collectUsedInputObjects(schema, selection.variableDefinitions);
+				for (const inputName of usedInputObjects) {
+					group.inputObjects.add(inputName);
+				}
+				const outputType = (0, __soda_gql_core.calculateFieldsType)(schema, selection.fields, outputFormatters);
+				const inputType = (0, __soda_gql_core.generateInputType)(schema, selection.variableDefinitions, inputFormatters);
+				group.operations.push({
+					key: selection.operationName,
+					inputType,
+					outputType
+				});
+			} catch (error) {
+				warnings.push(`[prebuilt] Failed to calculate type for operation "${selection.operationName}": ${error instanceof Error ? error.message : String(error)}`);
+			}
+		}
+	}
+	return (0, neverthrow.ok)({
+		grouped,
+		warnings
+	});
+};
+/**
+* Calculate relative import path from one file to another.
+*/
+const toImportSpecifier$1 = (from, to) => {
+	const fromDir = (0, node_path.dirname)(from);
+	let relativePath = (0, node_path.relative)(fromDir, to);
+	if (!relativePath.startsWith(".")) {
+		relativePath = `./${relativePath}`;
+	}
+	return relativePath.replace(/\.ts$/, "");
+};
+/**
+* Extract input object names from a GraphQL TypeNode.
+*/
+const extractInputObjectsFromType = (schema, typeNode, inputObjects) => {
+	switch (typeNode.kind) {
+		case graphql.Kind.NON_NULL_TYPE:
+			extractInputObjectsFromType(schema, typeNode.type, inputObjects);
+			break;
+		case graphql.Kind.LIST_TYPE:
+			extractInputObjectsFromType(schema, typeNode.type, inputObjects);
+			break;
+		case graphql.Kind.NAMED_TYPE: {
+			const name = typeNode.name.value;
+			if (!schema.scalar[name] && !schema.enum[name] && schema.input[name]) {
+				inputObjects.add(name);
+			}
+			break;
+		}
+	}
+};
+/**
+* Recursively collect nested input objects from schema definitions.
+* Takes a set of initial input names and expands to include all nested inputs.
+*/
+const collectNestedInputObjects = (schema, initialInputNames) => {
+	const inputObjects = new Set(initialInputNames);
+	const collectNested = (inputName, seen) => {
+		if (seen.has(inputName)) {
+			return;
+		}
+		seen.add(inputName);
+		const inputDef = schema.input[inputName];
+		if (!inputDef) {
+			return;
+		}
+		for (const field of Object.values(inputDef.fields)) {
+			if (field.kind === "input" && !inputObjects.has(field.name)) {
+				inputObjects.add(field.name);
+				collectNested(field.name, seen);
+			}
+		}
+	};
+	for (const inputName of Array.from(initialInputNames)) {
+		collectNested(inputName, new Set());
+	}
+	return inputObjects;
+};
+/**
+* Collect all input object types used in variable definitions.
+* Recursively collects nested input objects from the schema.
+*/
+const collectUsedInputObjects = (schema, variableDefinitions) => {
+	const directInputs = new Set();
+	for (const varDef of variableDefinitions) {
+		extractInputObjectsFromType(schema, varDef.type, directInputs);
+	}
+	return collectNestedInputObjects(schema, directInputs);
+};
+/**
+* Collect all input object types used in InputTypeSpecifiers.
+* Recursively collects nested input objects from the schema.
+*/
+const collectUsedInputObjectsFromSpecifiers = (schema, specifiers) => {
+	const directInputs = new Set();
+	for (const specifier of Object.values(specifiers)) {
+		if (specifier.kind === "input" && schema.input[specifier.name]) {
+			directInputs.add(specifier.name);
+		}
+	}
+	return collectNestedInputObjects(schema, directInputs);
+};
+/**
+* Generate type definitions for input objects.
+*/
+const generateInputObjectTypeDefinitions = (schema, schemaName, inputNames) => {
+	const lines = [];
+	const defaultDepth = schema.__defaultInputDepth ?? 3;
+	const depthOverrides = schema.__inputDepthOverrides ?? {};
+	const formatters = {
+		scalarInput: (name) => `ScalarInput_${schemaName}<"${name}">`,
+		inputObject: (name) => `Input_${schemaName}_${name}`
+	};
+	const sortedNames = Array.from(inputNames).sort();
+	for (const inputName of sortedNames) {
+		const typeString = (0, __soda_gql_core.generateInputObjectType)(schema, inputName, {
+			defaultDepth,
+			depthOverrides,
+			formatters
+		});
+		lines.push(`type Input_${schemaName}_${inputName} = ${typeString};`);
+	}
+	return lines;
+};
+/**
+* Generate the TypeScript code for prebuilt types.
+*/
+const generateTypesCode = (grouped, schemas, injects, outdir) => {
+	const typesFilePath = (0, node_path.join)(outdir, "prebuilt", "types.ts");
+	const lines = [
+		"/**",
+		" * Prebuilt type registry.",
+		" *",
+		" * This file is auto-generated by @soda-gql/typegen.",
+		" * Do not edit manually.",
+		" *",
+		" * @module",
+		" * @generated",
+		" */",
+		"",
+		"import type { PrebuiltTypeRegistry } from \"@soda-gql/core\";"
+	];
+	for (const [schemaName, inject] of Object.entries(injects)) {
+		const relativePath = toImportSpecifier$1(typesFilePath, inject.scalars);
+		lines.push(`import type { scalar as scalar_${schemaName} } from "${relativePath}";`);
+	}
+	lines.push("");
+	for (const schemaName of Object.keys(injects)) {
+		lines.push(`type ScalarInput_${schemaName}<T extends keyof typeof scalar_${schemaName}> = ` + `typeof scalar_${schemaName}[T]["$type"]["input"];`);
+		lines.push(`type ScalarOutput_${schemaName}<T extends keyof typeof scalar_${schemaName}> = ` + `typeof scalar_${schemaName}[T]["$type"]["output"];`);
+	}
+	lines.push("");
+	for (const [schemaName, { fragments, operations, inputObjects }] of grouped) {
+		const schema = schemas[schemaName];
+		if (inputObjects.size > 0 && schema) {
+			lines.push("// Input object types");
+			const inputTypeLines = generateInputObjectTypeDefinitions(schema, schemaName, inputObjects);
+			lines.push(...inputTypeLines);
+			lines.push("");
+		}
+		const fragmentEntries = fragments.sort((a, b) => a.key.localeCompare(b.key)).map((f) => `    readonly "${f.key}": { 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} };`);
+		lines.push(`export type PrebuiltTypes_${schemaName} = {`);
+		lines.push("  readonly fragments: {");
+		if (fragmentEntries.length > 0) {
+			lines.push(...fragmentEntries);
+		}
+		lines.push("  };");
+		lines.push("  readonly operations: {");
+		if (operationEntries.length > 0) {
+			lines.push(...operationEntries);
+		}
+		lines.push("  };");
+		lines.push("} satisfies PrebuiltTypeRegistry;");
+		lines.push("");
+	}
+	return lines.join("\n");
+};
+/**
+* Emit prebuilt types to the prebuilt/types.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
+* types), those elements are skipped and warnings are collected rather than
+* failing the entire emission. This allows builds to succeed even when some
+* elements have issues, while still reporting problems via warnings.
+*
+* @param options - Emitter options including schemas, field selections, and output directory
+* @returns Result containing output path and warnings, or error if a hard failure occurs
+*
+* @example
+* ```typescript
+* const result = await emitPrebuiltTypes({
+*   schemas: { mySchema: schema },
+*   fieldSelections,
+*   outdir: "./generated",
+*   injects: { mySchema: { scalars: "./scalars.ts" } },
+* });
+*
+* if (result.isOk()) {
+*   console.log(`Generated: ${result.value.path}`);
+*   if (result.value.warnings.length > 0) {
+*     console.warn("Warnings:", result.value.warnings);
+*   }
+* }
+* ```
+*/
+const emitPrebuiltTypes = async (options) => {
+	const { schemas, fieldSelections, outdir, injects } = options;
+	const groupResult = groupBySchema(fieldSelections, schemas);
+	if (groupResult.isErr()) {
+		return (0, neverthrow.err)(groupResult.error);
+	}
+	const { grouped, warnings } = groupResult.value;
+	const code = generateTypesCode(grouped, schemas, injects, outdir);
+	const typesPath = (0, node_path.join)(outdir, "prebuilt", "types.ts");
+	try {
+		await (0, node_fs_promises.writeFile)(typesPath, code, "utf-8");
+		return (0, neverthrow.ok)({
+			path: typesPath,
+			warnings
+		});
+	} catch (error) {
+		return (0, neverthrow.err)(__soda_gql_builder.builderErrors.writeFailed(typesPath, `Failed to write prebuilt types: ${error instanceof Error ? error.message : String(error)}`, error));
+	}
+};
+
+//#endregion
+//#region packages/typegen/src/errors.ts
+/**
+* Error constructor helpers for concise error creation.
+*/
+const typegenErrors = {
+	codegenRequired: (outdir) => ({
+		code: "TYPEGEN_CODEGEN_REQUIRED",
+		message: `Generated graphql-system module not found at '${outdir}'. Run 'soda-gql codegen' first.`,
+		outdir
+	}),
+	schemaLoadFailed: (schemaNames, cause) => ({
+		code: "TYPEGEN_SCHEMA_LOAD_FAILED",
+		message: `Failed to load schemas: ${schemaNames.join(", ")}`,
+		schemaNames,
+		cause
+	}),
+	buildFailed: (message, cause) => ({
+		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
+	})
+};
+/**
+* Format TypegenError for console output (human-readable).
+*/
+const formatTypegenError = (error) => {
+	const lines = [];
+	lines.push(`Error [${error.code}]: ${error.message}`);
+	switch (error.code) {
+		case "TYPEGEN_CODEGEN_REQUIRED":
+			lines.push(`  Output directory: ${error.outdir}`);
+			lines.push("  Hint: Run 'soda-gql codegen' to generate the graphql-system module first.");
+			break;
+		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}`);
+	}
+	return lines.join("\n");
+};
+
+//#endregion
+//#region packages/typegen/src/prebuilt-generator.ts
+/**
+* Generate the prebuilt module code.
+*
+* This generates:
+* - prebuilt/index.ts: Uses createPrebuiltGqlElementComposer with types from PrebuiltTypes
+* - prebuilt/types.ts: Placeholder types that typegen will populate
+*/
+const generatePrebuiltModule = (schemas, options) => {
+	const schemaNames = Array.from(schemas.keys());
+	const typeImports = [];
+	const runtimeImports = [];
+	for (const name of schemaNames) {
+		typeImports.push(`Schema_${name}`, `FragmentBuilders_${name}`, `Context_${name}`);
+		runtimeImports.push(`__schema_${name}`, `__inputTypeMethods_${name}`, `__directiveMethods_${name}`);
+		const hasAdapter = options.injection?.get(name)?.adapterImportPath !== undefined;
+		if (hasAdapter) {
+			typeImports.push(`Adapter_${name}`);
+			runtimeImports.push(`__adapter_${name}`);
+		}
+	}
+	const gqlEntries = [];
+	for (const name of schemaNames) {
+		const document = schemas.get(name);
+		if (!document) continue;
+		const hasAdapter = options.injection?.get(name)?.adapterImportPath !== undefined;
+		if (hasAdapter) {
+			gqlEntries.push(`  ${name}: createPrebuiltGqlElementComposer<Schema_${name}, PrebuiltTypes_${name}, FragmentBuilders_${name}, typeof __directiveMethods_${name}, Context_${name}, Adapter_${name}>(__schema_${name}, { adapter: __adapter_${name}, inputTypeMethods: __inputTypeMethods_${name}, directiveMethods: __directiveMethods_${name} })`);
+		} else {
+			gqlEntries.push(`  ${name}: createPrebuiltGqlElementComposer<Schema_${name}, PrebuiltTypes_${name}, FragmentBuilders_${name}, typeof __directiveMethods_${name}, Context_${name}>(__schema_${name}, { inputTypeMethods: __inputTypeMethods_${name}, directiveMethods: __directiveMethods_${name} })`);
+		}
+	}
+	const indexCode = `\
+/**
+ * Prebuilt GQL module for bundler-compatible type resolution.
+ *
+ * This module uses createPrebuiltGqlElementComposer which looks up types
+ * from PrebuiltTypes instead of using complex type inference.
+ *
+ * @module
+ * @generated by @soda-gql/typegen
+ */
+
+import { createPrebuiltGqlElementComposer } from "@soda-gql/core";
+import {
+  ${runtimeImports.join(",\n  ")},
+  type ${typeImports.join(",\n  type ")},
+} from "${options.mainModulePath}";
+import type { ${schemaNames.map((name) => `PrebuiltTypes_${name}`).join(", ")} } from "./types";
+
+export const gql = {
+${gqlEntries.join(",\n")}
+};
+
+// Re-export types from main module
+export type { ${typeImports.join(", ")} };
+`;
+	const typesCode = `\
+/**
+ * Prebuilt type registry.
+ *
+ * This file contains placeholder types that will be populated by typegen
+ * when running \`soda-gql typegen\` command.
+ *
+ * @module
+ * @generated by @soda-gql/typegen
+ */
+
+import type { EmptyPrebuiltTypeRegistry } from "@soda-gql/core";
+
+${schemaNames.map((name) => `// Placeholder for ${name} schema - populated by typegen\nexport type PrebuiltTypes_${name} = EmptyPrebuiltTypeRegistry;`).join("\n\n")}
+`;
+	return {
+		indexCode,
+		typesCode
+	};
+};
+
+//#endregion
+//#region packages/typegen/src/runner.ts
+/**
+* Main typegen runner.
+*
+* Orchestrates the prebuilt type generation process:
+* 1. Load schemas from generated CJS bundle
+* 2. Generate prebuilt/index.ts
+* 3. Build artifact to evaluate elements
+* 4. Extract field selections
+* 5. Emit prebuilt/types.ts
+* 6. Bundle prebuilt module
+*
+* @module
+*/
+const extensionMap = {
+	".ts": ".js",
+	".tsx": ".js",
+	".mts": ".mjs",
+	".cts": ".cjs",
+	".js": ".js",
+	".mjs": ".mjs",
+	".cjs": ".cjs"
+};
+const toImportSpecifier = (fromPath, targetPath, options) => {
+	const fromDir = (0, node_path.dirname)(fromPath);
+	const normalized = (0, node_path.relative)(fromDir, targetPath).replace(/\\/g, "/");
+	const sourceExt = (0, node_path.extname)(targetPath);
+	if (!options?.includeExtension) {
+		if (normalized.length === 0) {
+			return `./${targetPath.slice(0, -sourceExt.length).split("/").pop()}`;
+		}
+		const withPrefix$1 = normalized.startsWith(".") ? normalized : `./${normalized}`;
+		const currentExt$1 = (0, node_path.extname)(withPrefix$1);
+		return currentExt$1 ? withPrefix$1.slice(0, -currentExt$1.length) : withPrefix$1;
+	}
+	const runtimeExt = extensionMap[sourceExt] ?? sourceExt;
+	if (normalized.length === 0) {
+		const base = runtimeExt !== sourceExt ? targetPath.slice(0, -sourceExt.length).split("/").pop() : targetPath.split("/").pop();
+		return `./${base}${runtimeExt}`;
+	}
+	const withPrefix = normalized.startsWith(".") ? normalized : `./${normalized}`;
+	if (!runtimeExt) {
+		return withPrefix;
+	}
+	if (withPrefix.endsWith(runtimeExt)) {
+		return withPrefix;
+	}
+	const currentExt = (0, node_path.extname)(withPrefix);
+	const withoutExt = currentExt ? withPrefix.slice(0, -currentExt.length) : withPrefix;
+	return `${withoutExt}${runtimeExt}`;
+};
+/**
+* Bundle the prebuilt module to CJS format.
+*/
+const bundlePrebuiltModule = async (sourcePath) => {
+	const sourceExt = (0, node_path.extname)(sourcePath);
+	const baseName = sourcePath.slice(0, -sourceExt.length);
+	const cjsPath = `${baseName}.cjs`;
+	await (0, esbuild.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 (0, node_fs_promises.mkdir)((0, node_path.dirname)(path), { recursive: true });
+	await (0, node_fs_promises.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 += `${(0, node_fs.readFileSync)(schemaPath, "utf-8")}\n`;
+		}
+		documents.set(name, (0, graphql.parse)(combinedSource));
+	}
+	return documents;
+};
+/**
+* Run the typegen process.
+*
+* This function:
+* 1. Loads schemas from the generated CJS bundle
+* 2. Generates prebuilt/index.ts using generatePrebuiltModule
+* 3. Creates a BuilderService and builds the artifact
+* 4. Extracts field selections from the artifact
+* 5. Emits prebuilt/types.ts using emitPrebuiltTypes
+* 6. Bundles the prebuilt module
+*
+* @param options - Typegen options including config
+* @returns Result containing success data or error
+*/
+const runTypegen = async (options) => {
+	const { config } = options;
+	const outdir = (0, node_path.resolve)(config.outdir);
+	const cjsPath = (0, node_path.join)(outdir, "index.cjs");
+	const importSpecifierOptions = { includeExtension: config.styles.importExtension };
+	if (!(0, node_fs.existsSync)(cjsPath)) {
+		return (0, neverthrow.err)(typegenErrors.codegenRequired(outdir));
+	}
+	const schemaNames = Object.keys(config.schemas);
+	const schemasResult = (0, __soda_gql_builder.loadSchemasFromBundle)(cjsPath, schemaNames);
+	if (schemasResult.isErr()) {
+		return (0, neverthrow.err)(typegenErrors.schemaLoadFailed(schemaNames, schemasResult.error));
+	}
+	const schemas = schemasResult.value;
+	const prebuiltDir = (0, node_path.join)(outdir, "prebuilt");
+	await (0, node_fs_promises.mkdir)(prebuiltDir, { recursive: true });
+	const schemaDocuments = loadSchemaDocuments(config.schemas);
+	const mainModulePath = toImportSpecifier((0, node_path.join)(prebuiltDir, "index.ts"), (0, node_path.join)(outdir, "index.ts"), importSpecifierOptions);
+	const injection = new Map();
+	for (const [schemaName, schemaConfig] of Object.entries(config.schemas)) {
+		if (schemaConfig.inject.adapter) {
+			injection.set(schemaName, { adapterImportPath: toImportSpecifier((0, node_path.join)(outdir, "index.ts"), schemaConfig.inject.adapter, importSpecifierOptions) });
+		} else {
+			injection.set(schemaName, {});
+		}
+	}
+	const prebuilt = generatePrebuiltModule(schemaDocuments, {
+		mainModulePath,
+		injection
+	});
+	const prebuiltIndexPath = (0, node_path.join)(prebuiltDir, "index.ts");
+	try {
+		await writeModule(prebuiltIndexPath, prebuilt.indexCode);
+	} catch (error) {
+		return (0, neverthrow.err)(typegenErrors.emitFailed(prebuiltIndexPath, `Failed to write prebuilt index: ${error instanceof Error ? error.message : String(error)}`, error));
+	}
+	const builderService = (0, __soda_gql_builder.createBuilderService)({ config });
+	const artifactResult = await builderService.buildAsync();
+	if (artifactResult.isErr()) {
+		return (0, neverthrow.err)(typegenErrors.buildFailed(`Builder failed: ${artifactResult.error.message}`, artifactResult.error));
+	}
+	const intermediateElements = builderService.getIntermediateElements();
+	if (!intermediateElements) {
+		return (0, neverthrow.err)(typegenErrors.buildFailed("No intermediate elements available after build", undefined));
+	}
+	const fieldSelectionsResult = (0, __soda_gql_builder.extractFieldSelections)(intermediateElements);
+	const { selections: fieldSelections, warnings: extractWarnings } = fieldSelectionsResult;
+	const injects = {};
+	for (const [schemaName, schemaConfig] of Object.entries(config.schemas)) {
+		injects[schemaName] = { scalars: schemaConfig.inject.scalars };
+	}
+	const emitResult = await emitPrebuiltTypes({
+		schemas,
+		fieldSelections,
+		outdir,
+		injects
+	});
+	if (emitResult.isErr()) {
+		return (0, neverthrow.err)(emitResult.error);
+	}
+	const { path: prebuiltTypesPath, warnings: emitWarnings } = emitResult.value;
+	try {
+		await bundlePrebuiltModule(prebuiltIndexPath);
+	} catch (error) {
+		return (0, neverthrow.err)(typegenErrors.bundleFailed(prebuiltIndexPath, `Failed to bundle prebuilt module: ${error instanceof Error ? error.message : String(error)}`, error));
+	}
+	let fragmentCount = 0;
+	let operationCount = 0;
+	for (const selection of fieldSelections.values()) {
+		if (selection.type === "fragment" && selection.key) {
+			fragmentCount++;
+		} else if (selection.type === "operation") {
+			operationCount++;
+		}
+	}
+	const allWarnings = [...extractWarnings, ...emitWarnings];
+	return (0, neverthrow.ok)({
+		prebuiltIndexPath,
+		prebuiltTypesPath,
+		fragmentCount,
+		operationCount,
+		warnings: allWarnings
+	});
+};
+
+//#endregion
+exports.emitPrebuiltTypes = emitPrebuiltTypes;
+exports.formatTypegenError = formatTypegenError;
+exports.generatePrebuiltModule = generatePrebuiltModule;
+exports.runTypegen = runTypegen;
+exports.typegenErrors = typegenErrors;
+//# sourceMappingURL=index.cjs.map