@soda-gql/typegen 0.10.1 → 0.10.2

package/dist/index.cjs

@@ -7,6 +7,78 @@ let neverthrow = require("neverthrow");
 let node_fs = require("node:fs");
 let esbuild = require("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 @@ let esbuild = require("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 (0, neverthrow.err)(typegenErrors.fragmentMissingKey(missingKeyFragments));
+	}
 	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) => {
@@ -210,8 +284,8 @@ const generateInputObjectTypeDefinitions = (schema, schemaName, inputNames) => {
 /**
 * Generate the TypeScript code for prebuilt types.
 */
-const generateTypesCode = (grouped, schemas, injects, outdir) => {
-	const typesFilePath = (0, node_path.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 (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");
+	const code = generateTypesCode(grouped, schemas, injectsModulePath);
+	const typesPath = (0, node_path.join)(outdir, "types.prebuilt.ts");
 	try {
 		await (0, node_fs_promises.writeFile)(typesPath, code, "utf-8");
 		return (0, neverthrow.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 (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 prebuiltIndexPath = (0, node_path.join)(outdir, "index.prebuilt.ts");
+	const internalModulePath = toImportSpecifier(prebuiltIndexPath, (0, node_path.join)(outdir, "_internal.ts"), importSpecifierOptions);
+	const injectsModulePath = toImportSpecifier(prebuiltIndexPath, (0, node_path.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((0, node_path.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 = (0, node_path.join)(prebuiltDir, "index.ts");
 	try {
 		await writeModule(prebuiltIndexPath, prebuilt.indexCode);
 	} catch (error) {
@@ -605,15 +621,11 @@ const runTypegen = async (options) => {
 	}
 	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
+		injectsModulePath
 	});
 	if (emitResult.isErr()) {
 		return (0, neverthrow.err)(emitResult.error);