@soda-gql/typegen 0.10.1 → 0.10.2

package/dist/index.d.mts

@@ -4,6 +4,71 @@ import { DocumentNode } from "graphql";
 import { Result } from "neverthrow";
 import { ResolvedSodaGqlConfig } from "@soda-gql/config";
 
+//#region packages/typegen/src/errors.d.ts
+
+/**
+ * Error codes specific to typegen operations.
+ */
+type TypegenErrorCode = "TYPEGEN_CODEGEN_REQUIRED" | "TYPEGEN_SCHEMA_LOAD_FAILED" | "TYPEGEN_BUILD_FAILED" | "TYPEGEN_EMIT_FAILED" | "TYPEGEN_BUNDLE_FAILED" | "TYPEGEN_FRAGMENT_MISSING_KEY";
+/**
+ * Typegen-specific error type.
+ */
+type TypegenSpecificError = {
+  readonly code: "TYPEGEN_CODEGEN_REQUIRED";
+  readonly message: string;
+  readonly outdir: string;
+} | {
+  readonly code: "TYPEGEN_SCHEMA_LOAD_FAILED";
+  readonly message: string;
+  readonly schemaNames: readonly string[];
+  readonly cause?: unknown;
+} | {
+  readonly code: "TYPEGEN_BUILD_FAILED";
+  readonly message: string;
+  readonly cause?: unknown;
+} | {
+  readonly code: "TYPEGEN_EMIT_FAILED";
+  readonly message: string;
+  readonly path: string;
+  readonly cause?: unknown;
+} | {
+  readonly code: "TYPEGEN_BUNDLE_FAILED";
+  readonly message: string;
+  readonly path: string;
+  readonly cause?: unknown;
+} | {
+  readonly code: "TYPEGEN_FRAGMENT_MISSING_KEY";
+  readonly message: string;
+  readonly fragments: readonly {
+    readonly canonicalId: string;
+    readonly typename: string;
+    readonly schemaLabel: string;
+  }[];
+};
+/**
+ * Union of all typegen errors (specific + builder errors).
+ */
+type TypegenError = TypegenSpecificError | BuilderError;
+/**
+ * Error constructor helpers for concise error creation.
+ */
+declare const typegenErrors: {
+  readonly codegenRequired: (outdir: string) => TypegenSpecificError;
+  readonly schemaLoadFailed: (schemaNames: readonly string[], cause?: unknown) => TypegenSpecificError;
+  readonly buildFailed: (message: string, cause?: unknown) => TypegenSpecificError;
+  readonly emitFailed: (path: string, message: string, cause?: unknown) => TypegenSpecificError;
+  readonly bundleFailed: (path: string, message: string, cause?: unknown) => TypegenSpecificError;
+  readonly fragmentMissingKey: (fragments: readonly {
+    canonicalId: string;
+    typename: string;
+    schemaLabel: string;
+  }[]) => TypegenSpecificError;
+};
+/**
+ * Format TypegenError for console output (human-readable).
+ */
+declare const formatTypegenError: (error: TypegenError) => string;
+//#endregion
 //#region packages/typegen/src/emitter.d.ts
 
 /**
@@ -25,12 +90,10 @@ type PrebuiltTypesEmitterOptions = {
    */
   readonly outdir: string;
   /**
-   * Inject configuration per schema.
-   * Maps schema name to inject file paths (absolute paths).
+   * Relative import path to _internal-injects.ts from types.prebuilt.ts.
+   * Example: "./_internal-injects"
    */
-  readonly injects: Record<string, {
-    readonly scalars: string;
-  }>;
+  readonly injectsModulePath: string;
 };
 /**
  * Result of emitting prebuilt types.
@@ -68,85 +131,41 @@ type PrebuiltTypesEmitResult = {
  * }
  * ```
  */
-declare const emitPrebuiltTypes: (options: PrebuiltTypesEmitterOptions) => Promise<Result<PrebuiltTypesEmitResult, BuilderError>>;
-//#endregion
-//#region packages/typegen/src/errors.d.ts
-/**
- * Error codes specific to typegen operations.
- */
-type TypegenErrorCode = "TYPEGEN_CODEGEN_REQUIRED" | "TYPEGEN_SCHEMA_LOAD_FAILED" | "TYPEGEN_BUILD_FAILED" | "TYPEGEN_EMIT_FAILED" | "TYPEGEN_BUNDLE_FAILED";
-/**
- * Typegen-specific error type.
- */
-type TypegenSpecificError = {
-  readonly code: "TYPEGEN_CODEGEN_REQUIRED";
-  readonly message: string;
-  readonly outdir: string;
-} | {
-  readonly code: "TYPEGEN_SCHEMA_LOAD_FAILED";
-  readonly message: string;
-  readonly schemaNames: readonly string[];
-  readonly cause?: unknown;
-} | {
-  readonly code: "TYPEGEN_BUILD_FAILED";
-  readonly message: string;
-  readonly cause?: unknown;
-} | {
-  readonly code: "TYPEGEN_EMIT_FAILED";
-  readonly message: string;
-  readonly path: string;
-  readonly cause?: unknown;
-} | {
-  readonly code: "TYPEGEN_BUNDLE_FAILED";
-  readonly message: string;
-  readonly path: string;
-  readonly cause?: unknown;
-};
-/**
- * Union of all typegen errors (specific + builder errors).
- */
-type TypegenError = TypegenSpecificError | BuilderError;
-/**
- * Error constructor helpers for concise error creation.
- */
-declare const typegenErrors: {
-  readonly codegenRequired: (outdir: string) => TypegenSpecificError;
-  readonly schemaLoadFailed: (schemaNames: readonly string[], cause?: unknown) => TypegenSpecificError;
-  readonly buildFailed: (message: string, cause?: unknown) => TypegenSpecificError;
-  readonly emitFailed: (path: string, message: string, cause?: unknown) => TypegenSpecificError;
-  readonly bundleFailed: (path: string, message: string, cause?: unknown) => TypegenSpecificError;
-};
-/**
- * Format TypegenError for console output (human-readable).
- */
-declare const formatTypegenError: (error: TypegenError) => string;
+declare const emitPrebuiltTypes: (options: PrebuiltTypesEmitterOptions) => Promise<Result<PrebuiltTypesEmitResult, BuilderError | TypegenError>>;
 //#endregion
 //#region packages/typegen/src/prebuilt-generator.d.ts
 type PrebuiltGeneratorOptions = {
   /**
-   * Relative import path to the main gql module.
-   * Example: "../index" (from prebuilt/index.ts to index.ts)
+   * Relative import path to the internal module.
+   * Example: "./_internal" (from index.prebuilt.ts to _internal.ts)
+   */
+  readonly internalModulePath: string;
+  /**
+   * Relative import path to the injects module.
+   * Example: "./_internal-injects" (from index.prebuilt.ts to _internal-injects.ts)
    */
-  readonly mainModulePath: string;
+  readonly injectsModulePath: string;
   /**
-   * Per-schema injection config (adapter import paths).
+   * Per-schema injection config.
+   * Maps schema name to whether it has an adapter.
    */
   readonly injection?: Map<string, {
-    readonly adapterImportPath?: string;
+    readonly hasAdapter?: boolean;
   }>;
 };
 type PrebuiltGeneratedModule = {
-  /** The generated code for prebuilt/index.ts */
+  /** The generated code for index.prebuilt.ts */
   readonly indexCode: string;
-  /** The generated code for prebuilt/types.ts (placeholder) */
-  readonly typesCode: string;
 };
 /**
- * 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 prebuilt gql composers using
+ * createPrebuiltGqlElementComposer. The generated module uses
+ * lightweight imports for type serialization compatibility:
+ * - Adapters from _internal-injects.ts
+ * - Runtime values from _internal.ts
+ * - AnyGqlContext instead of heavy Context type inference
  */
 declare const generatePrebuiltModule: (schemas: Map<string, DocumentNode>, options: PrebuiltGeneratorOptions) => PrebuiltGeneratedModule;
 //#endregion
@@ -221,10 +240,10 @@ type RunTypegenOptions = {
  *
  * 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

package/dist/index.d.mts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.mts","names":[],"sources":["../src/emitter.ts","../src/errors.ts","../src/prebuilt-generator.ts","../src/types.ts","../src/runner.ts"],"sourcesContent":[],"mappings":"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"}
+{"version":3,"file":"index.d.mts","names":[],"sources":["../src/errors.ts","../src/emitter.ts","../src/prebuilt-generator.ts","../src/types.ts","../src/runner.ts"],"sourcesContent":[],"mappings":"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"}

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 {
@@ -98,23 +180,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 +284,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 +299,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"];`);
 	}
@@ -291,14 +363,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 +382,91 @@ 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 prebuilt gql composers using
+* createPrebuiltGqlElementComposer. The generated module uses
+* lightweight imports for type serialization compatibility:
+* - Adapters from _internal-injects.ts
+* - Runtime values from _internal.ts
+* - AnyGqlContext instead of heavy Context type inference
 */
 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 gqlEntries = schemaNames.map((name) => {
+		const config = injection.get(name);
+		const adapterArg = config?.hasAdapter ? `adapter: adapter_${name},` : "";
+		return `  ${name}: createPrebuiltGqlElementComposer<
+    AnyGraphqlSchema,
+    PrebuiltTypes_${name},
+    Record<string, unknown>,
+    StandardDirectives,
+    AnyGqlContext
+  >(
+    __schema_${name} as AnyGraphqlSchema,
+    {
+      inputTypeMethods: __inputTypeMethods_${name},
+      directiveMethods: __directiveMethods_${name},
+      ${adapterArg}
+    }
+  )`;
+	});
+	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.
  *
- * This module uses createPrebuiltGqlElementComposer which looks up types
- * from PrebuiltTypes instead of using complex type inference.
+ * This module creates prebuilt composers using createPrebuiltGqlElementComposer
+ * that look up types from PrebuiltTypes instead of complex inference.
+ *
+ * Uses lightweight imports:
+ * - Adapters from _internal-injects.ts
+ * - Runtime values from _internal.ts
+ * - AnyGqlContext instead of heavy Context 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")}
-};
+  createPrebuiltGqlElementComposer,
+  type AnyGqlContext,
+  type AnyGraphqlSchema,
+  type StandardDirectives,
+} from "@soda-gql/core";
+${injectsImportLine}
+import { ${internalImports.join(", ")} } from "${options.internalModulePath}";
+import type { ${schemaNames.map((name) => `PrebuiltTypes_${name}`).join(", ")} } from "./types.prebuilt";
 
-// 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 strict type resolution from PrebuiltTypeRegistry.
  *
- * @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
+ * instead of using complex type inference.
  */
-
-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 = {
+${gqlEntries.join(",\n")}
+};
 `;
-	return {
-		indexCode,
-		typesCode
-	};
+	return { indexCode };
 };
 
 //#endregion
@@ -456,10 +476,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 +569,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 +592,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 +621,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);