@soda-gql/typegen 0.10.1 → 0.11.0

package/dist/index.mjs

@@ -7,6 +7,78 @@ import { err, ok } from "neverthrow";
 import { existsSync, readFileSync } from "node:fs";
 import { build } from "esbuild";
 
+//#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
+	}),
+	fragmentMissingKey: (fragments) => ({
+		code: "TYPEGEN_FRAGMENT_MISSING_KEY",
+		message: `${fragments.length} fragment(s) missing required 'key' property for prebuilt types`,
+		fragments
+	})
+};
+/**
+* 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;
+		case "TYPEGEN_FRAGMENT_MISSING_KEY":
+			lines.push("  Fragments missing 'key' property:");
+			for (const fragment of error.fragments) {
+				lines.push(`    - ${fragment.canonicalId} (${fragment.typename} on ${fragment.schemaLabel})`);
+			}
+			lines.push("  Hint: Add a 'key' property to each fragment for prebuilt type resolution.");
+			break;
+	}
+	if ("cause" in error && error.cause) {
+		lines.push(`  Caused by: ${error.cause}`);
+	}
+	return lines.join("\n");
+};
+
+//#endregion
 //#region packages/typegen/src/emitter.ts
 /**
 * Prebuilt types emitter.
@@ -36,11 +108,16 @@ import { build } from "esbuild";
 * Group field selections by schema.
 * Uses the schemaLabel from each selection to group them correctly.
 *
+* In strict mode, all fragments must have a 'key' property. Fragments
+* without keys will cause an error.
+*
 * @returns Result containing grouped selections and warnings, or error if schema not found
+*          or fragments are missing keys
 */
 const groupBySchema = (fieldSelections, schemas) => {
 	const grouped = new Map();
 	const warnings = [];
+	const missingKeyFragments = [];
 	for (const schemaName of Object.keys(schemas)) {
 		grouped.set(schemaName, {
 			fragments: [],
@@ -62,6 +139,11 @@ const groupBySchema = (fieldSelections, schemas) => {
 		};
 		if (selection.type === "fragment") {
 			if (!selection.key) {
+				missingKeyFragments.push({
+					canonicalId,
+					typename: selection.typename,
+					schemaLabel: selection.schemaLabel
+				});
 				continue;
 			}
 			try {
@@ -74,6 +156,7 @@ const groupBySchema = (fieldSelections, schemas) => {
 				const inputType = hasVariables ? generateInputTypeFromSpecifiers(schema, selection.variableDefinitions, { formatters: inputFormatters }) : "void";
 				group.fragments.push({
 					key: selection.key,
+					typename: selection.typename,
 					inputType,
 					outputType
 				});
@@ -98,23 +181,15 @@ const groupBySchema = (fieldSelections, schemas) => {
 			}
 		}
 	}
+	if (missingKeyFragments.length > 0) {
+		return err(typegenErrors.fragmentMissingKey(missingKeyFragments));
+	}
 	return ok({
 		grouped,
 		warnings
 	});
 };
 /**
-* Calculate relative import path from one file to another.
-*/
-const toImportSpecifier$1 = (from, to) => {
-	const fromDir = dirname(from);
-	let relativePath = 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) => {
@@ -210,8 +285,8 @@ const generateInputObjectTypeDefinitions = (schema, schemaName, inputNames) => {
 /**
 * Generate the TypeScript code for prebuilt types.
 */
-const generateTypesCode = (grouped, schemas, injects, outdir) => {
-	const typesFilePath = join(outdir, "prebuilt", "types.ts");
+const generateTypesCode = (grouped, schemas, injectsModulePath) => {
+	const schemaNames = Object.keys(schemas);
 	const lines = [
 		"/**",
 		" * Prebuilt type registry.",
@@ -225,12 +300,10 @@ const generateTypesCode = (grouped, schemas, injects, outdir) => {
 		"",
 		"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}";`);
-	}
+	const scalarImports = schemaNames.map((name) => `scalar_${name}`).join(", ");
+	lines.push(`import type { ${scalarImports} } from "${injectsModulePath}";`);
 	lines.push("");
-	for (const schemaName of Object.keys(injects)) {
+	for (const schemaName of schemaNames) {
 		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"];`);
 	}
@@ -243,7 +316,7 @@ const generateTypesCode = (grouped, schemas, injects, outdir) => {
 			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 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} };`);
 		lines.push(`export type PrebuiltTypes_${schemaName} = {`);
 		lines.push("  readonly fragments: {");
@@ -256,7 +329,7 @@ const generateTypesCode = (grouped, schemas, injects, outdir) => {
 			lines.push(...operationEntries);
 		}
 		lines.push("  };");
-		lines.push("} satisfies PrebuiltTypeRegistry;");
+		lines.push("};");
 		lines.push("");
 	}
 	return lines.join("\n");
@@ -291,14 +364,14 @@ const generateTypesCode = (grouped, schemas, injects, outdir) => {
 * ```
 */
 const emitPrebuiltTypes = async (options) => {
-	const { schemas, fieldSelections, outdir, injects } = options;
+	const { schemas, fieldSelections, outdir, injectsModulePath } = options;
 	const groupResult = groupBySchema(fieldSelections, schemas);
 	if (groupResult.isErr()) {
 		return err(groupResult.error);
 	}
 	const { grouped, warnings } = groupResult.value;
-	const code = generateTypesCode(grouped, schemas, injects, outdir);
-	const typesPath = join(outdir, "prebuilt", "types.ts");
+	const code = generateTypesCode(grouped, schemas, injectsModulePath);
+	const typesPath = join(outdir, "types.prebuilt.ts");
 	try {
 		await writeFile(typesPath, code, "utf-8");
 		return ok({
@@ -310,143 +383,193 @@ const emitPrebuiltTypes = async (options) => {
 	}
 };
 
-//#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.
+* Generate the prebuilt index module code.
 *
-* This generates:
-* - prebuilt/index.ts: Uses createPrebuiltGqlElementComposer with types from PrebuiltTypes
-* - prebuilt/types.ts: Placeholder types that typegen will populate
+* 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.
 */
 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 = [];
+	const injection = options.injection ?? new Map();
+	const adapterImports = [];
 	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 config = injection.get(name);
+		if (config?.hasAdapter) {
+			adapterImports.push(`adapter_${name}`);
 		}
 	}
+	const internalImports = schemaNames.flatMap((name) => [
+		`__schema_${name}`,
+		`__inputTypeMethods_${name}`,
+		`__directiveMethods_${name}`
+	]);
+	const genericTypes = `
+/**
+ * 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;
+
+/**
+ * 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>;
+};
+`;
+	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">>;
+
+/**
+ * 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">
+    >;
+
+/**
+ * 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>;
+
+/**
+ * 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>;
+
+/**
+ * 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 = `\
 /**
- * Prebuilt GQL module for bundler-compatible type resolution.
+ * Prebuilt GQL module with builder-level type resolution.
  *
- * This module uses createPrebuiltGqlElementComposer which looks up types
- * from PrebuiltTypes instead of using complex type inference.
+ * 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 { 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";
+  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 const gql = {
-${gqlEntries.join(",\n")}
-};
+// 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")}
 
-// 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.
+ * Prebuilt GQL composers with builder-level type resolution.
  *
- * @module
- * @generated by @soda-gql/typegen
+ * 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.
  */
-
-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")}
+export const gql: { ${schemaNames.map((name) => `${name}: GqlComposer_${name}`).join("; ")} } = {
+${gqlEntries.join(",\n")}
+};
 `;
-	return {
-		indexCode,
-		typesCode
-	};
+	return { indexCode };
 };
 
 //#endregion
@@ -456,10 +579,10 @@ ${schemaNames.map((name) => `// Placeholder for ${name} schema - populated by ty
 *
 * Orchestrates the prebuilt type generation process:
 * 1. Load schemas from generated CJS bundle
-* 2. Generate prebuilt/index.ts
+* 2. Generate index.prebuilt.ts
 * 3. Build artifact to evaluate elements
 * 4. Extract field selections
-* 5. Emit prebuilt/types.ts
+* 5. Emit types.prebuilt.ts
 * 6. Bundle prebuilt module
 *
 * @module
@@ -549,10 +672,10 @@ const loadSchemaDocuments = (schemasConfig) => {
 *
 * This function:
 * 1. Loads schemas from the generated CJS bundle
-* 2. Generates prebuilt/index.ts using generatePrebuiltModule
+* 2. Generates index.prebuilt.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
+* 5. Emits types.prebuilt.ts using emitPrebuiltTypes
 * 6. Bundles the prebuilt module
 *
 * @param options - Typegen options including config
@@ -572,23 +695,19 @@ const runTypegen = async (options) => {
 		return err(typegenErrors.schemaLoadFailed(schemaNames, schemasResult.error));
 	}
 	const schemas = schemasResult.value;
-	const prebuiltDir = join(outdir, "prebuilt");
-	await mkdir(prebuiltDir, { recursive: true });
 	const schemaDocuments = loadSchemaDocuments(config.schemas);
-	const mainModulePath = toImportSpecifier(join(prebuiltDir, "index.ts"), join(outdir, "index.ts"), importSpecifierOptions);
+	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)) {
-		if (schemaConfig.inject.adapter) {
-			injection.set(schemaName, { adapterImportPath: toImportSpecifier(join(outdir, "index.ts"), schemaConfig.inject.adapter, importSpecifierOptions) });
-		} else {
-			injection.set(schemaName, {});
-		}
+		injection.set(schemaName, { hasAdapter: !!schemaConfig.inject.adapter });
 	}
 	const prebuilt = generatePrebuiltModule(schemaDocuments, {
-		mainModulePath,
+		internalModulePath,
+		injectsModulePath,
 		injection
 	});
-	const prebuiltIndexPath = join(prebuiltDir, "index.ts");
 	try {
 		await writeModule(prebuiltIndexPath, prebuilt.indexCode);
 	} catch (error) {
@@ -605,15 +724,11 @@ const runTypegen = async (options) => {
 	}
 	const fieldSelectionsResult = 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
+		injectsModulePath
 	});
 	if (emitResult.isErr()) {
 		return err(emitResult.error);