@soda-gql/codegen 0.11.10 → 0.11.12

package/dist/index.mjs

@@ -1,11 +1,675 @@
-import { n as generateMultiSchemaModule } from "./generator-1A_wwhEm.mjs";
+import { n as generateMultiSchemaModule, t as createSchemaIndex } from "./generator-BJlFKC6z.mjs";
+import { err, ok } from "neverthrow";
+import { Kind, concatAST, parse, print } from "graphql";
 import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
 import { basename, dirname, extname, join, relative, resolve } from "node:path";
-import { err, ok } from "neverthrow";
 import { build } from "esbuild";
-import { concatAST, parse, print } from "graphql";
 import { createHash } from "node:crypto";
 
+//#region packages/codegen/src/graphql-compat/emitter.ts
+/**
+* Emit TypeScript code for an operation.
+*/
+const emitOperation = (operation, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	lines.push(`import { gql } from "${options.graphqlSystemPath}";`);
+	if (operation.fragmentDependencies.length > 0 && options.fragmentImports) {
+		for (const fragName of operation.fragmentDependencies) {
+			const importPath = options.fragmentImports.get(fragName);
+			if (importPath) {
+				lines.push(`import { ${fragName}Fragment } from "${importPath}";`);
+			}
+		}
+	}
+	lines.push("");
+	const exportName = `${operation.name}Compat`;
+	const operationType = operation.kind;
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ ${operationType}, $var }) =>`);
+	lines.push(`  ${operationType}.compat({`);
+	lines.push(`    name: ${JSON.stringify(operation.name)},`);
+	if (operation.variables.length > 0) {
+		lines.push(`    variables: { ${emitVariables(operation.variables)} },`);
+	}
+	lines.push(`    fields: ({ f, $ }) => ({`);
+	const fieldLinesResult = emitSelections(operation.selections, 3, operation.variables, schema);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit TypeScript code for a fragment.
+*/
+const emitFragment = (fragment, options) => {
+	const lines = [];
+	const schema = options.schemaDocument ? createSchemaIndex(options.schemaDocument) : null;
+	lines.push(`import { gql } from "${options.graphqlSystemPath}";`);
+	if (fragment.fragmentDependencies.length > 0 && options.fragmentImports) {
+		for (const fragName of fragment.fragmentDependencies) {
+			const importPath = options.fragmentImports.get(fragName);
+			if (importPath) {
+				lines.push(`import { ${fragName}Fragment } from "${importPath}";`);
+			}
+		}
+	}
+	lines.push("");
+	const exportName = `${fragment.name}Fragment`;
+	lines.push(`export const ${exportName} = gql.${options.schemaName}(({ fragment }) =>`);
+	lines.push(`  fragment.${fragment.onType}({`);
+	lines.push(`    fields: ({ f }) => ({`);
+	const fieldLinesResult = emitSelections(fragment.selections, 3, [], schema);
+	if (fieldLinesResult.isErr()) {
+		return err(fieldLinesResult.error);
+	}
+	lines.push(fieldLinesResult.value);
+	lines.push(`    }),`);
+	lines.push(`  }),`);
+	lines.push(`);`);
+	return ok(lines.join("\n"));
+};
+/**
+* Emit variable definitions.
+*/
+const emitVariables = (variables) => {
+	return variables.map((v) => `...$var(${JSON.stringify(v.name)}).${v.typeName}(${JSON.stringify(v.modifier)})`).join(", ");
+};
+/**
+* Emit field selections (public API).
+* Converts EnrichedVariable[] to Set<string> and delegates to internal implementation.
+*/
+const emitSelections = (selections, indent, variables, schema) => {
+	const variableNames = new Set(variables.map((v) => v.name));
+	return emitSelectionsInternal(selections, indent, variableNames, schema);
+};
+/**
+* Internal implementation for emitting field selections.
+* Takes variableNames as Set<string> for recursive calls.
+*/
+const emitSelectionsInternal = (selections, indent, variableNames, schema) => {
+	const lines = [];
+	const inlineFragments = [];
+	const otherSelections = [];
+	for (const sel of selections) {
+		if (sel.kind === "inlineFragment") {
+			inlineFragments.push(sel);
+		} else {
+			otherSelections.push(sel);
+		}
+	}
+	for (const sel of otherSelections) {
+		const result = emitSingleSelection(sel, indent, variableNames, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		lines.push(result.value);
+	}
+	if (inlineFragments.length > 0) {
+		const unionResult = emitInlineFragmentsAsUnion(inlineFragments, indent, variableNames, schema);
+		if (unionResult.isErr()) {
+			return err(unionResult.error);
+		}
+		lines.push(unionResult.value);
+	}
+	return ok(lines.join("\n"));
+};
+/**
+* Emit a single selection (field or fragment spread).
+*/
+const emitSingleSelection = (sel, indent, variableNames, schema) => {
+	const padding = "  ".repeat(indent);
+	switch (sel.kind) {
+		case "field": return emitFieldSelection(sel, indent, variableNames, schema);
+		case "fragmentSpread": return ok(`${padding}...${sel.name}Fragment.spread(),`);
+		case "inlineFragment": return ok("");
+	}
+};
+/**
+* Emit inline fragments grouped as a union selection.
+* Format: { TypeA: ({ f }) => ({ ...fields }), TypeB: ({ f }) => ({ ...fields }) }
+*/
+const emitInlineFragmentsAsUnion = (inlineFragments, indent, variableNames, schema) => {
+	const padding = "  ".repeat(indent);
+	for (const frag of inlineFragments) {
+		if (frag.onType === "") {
+			return err({
+				code: "GRAPHQL_INLINE_FRAGMENT_WITHOUT_TYPE",
+				message: "Inline fragments without type condition are not supported. Use `... on TypeName { }` syntax."
+			});
+		}
+	}
+	for (const frag of inlineFragments) {
+		if (schema && !schema.objects.has(frag.onType)) {
+			let isUnionMember = false;
+			for (const [, unionDef] of schema.unions) {
+				if (unionDef.members.has(frag.onType)) {
+					isUnionMember = true;
+					break;
+				}
+			}
+			if (!isUnionMember) {
+				return err({
+					code: "GRAPHQL_INLINE_FRAGMENT_ON_INTERFACE",
+					message: `Inline fragments on interface type "${frag.onType}" are not supported. Use union types instead.`,
+					onType: frag.onType
+				});
+			}
+		}
+	}
+	const entries = [];
+	for (const frag of inlineFragments) {
+		const innerPadding = "  ".repeat(indent + 1);
+		const fieldsResult = emitSelectionsInternal(frag.selections, indent + 2, variableNames, schema);
+		if (fieldsResult.isErr()) {
+			return err(fieldsResult.error);
+		}
+		entries.push(`${innerPadding}${frag.onType}: ({ f }) => ({
+${fieldsResult.value}
+${innerPadding}}),`);
+	}
+	return ok(`${padding}...({
+${entries.join("\n")}
+${padding}}),`);
+};
+/**
+* Emit a single field selection.
+*/
+const emitFieldSelection = (field, indent, variableNames, schema) => {
+	const padding = "  ".repeat(indent);
+	const args = field.arguments;
+	const selections = field.selections;
+	const hasArgs = args && args.length > 0;
+	const hasSelections = selections && selections.length > 0;
+	let line = `${padding}...f.${field.name}(`;
+	if (hasArgs) {
+		const argsResult = emitArguments(args, variableNames);
+		if (argsResult.isErr()) {
+			return err(argsResult.error);
+		}
+		line += argsResult.value;
+	}
+	line += ")";
+	if (hasSelections) {
+		const hasInlineFragments = selections.some((s) => s.kind === "inlineFragment");
+		if (hasInlineFragments) {
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += "({\n";
+			line += `${nestedResult.value}\n`;
+			line += `${padding}})`;
+		} else {
+			line += "(({ f }) => ({\n";
+			const nestedResult = emitSelectionsInternal(selections, indent + 1, variableNames, schema);
+			if (nestedResult.isErr()) {
+				return err(nestedResult.error);
+			}
+			line += `${nestedResult.value}\n`;
+			line += `${padding}}))`;
+		}
+	}
+	line += ",";
+	return ok(line);
+};
+/**
+* Emit field arguments.
+*/
+const emitArguments = (args, variableNames) => {
+	if (args.length === 0) {
+		return ok("");
+	}
+	const argEntries = [];
+	for (const arg of args) {
+		const result = emitValue(arg.value, variableNames);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		argEntries.push(`${arg.name}: ${result.value}`);
+	}
+	return ok(`{ ${argEntries.join(", ")} }`);
+};
+/**
+* Emit a value (literal or variable reference).
+*/
+const emitValue = (value, variableNames) => {
+	switch (value.kind) {
+		case "variable":
+			if (variableNames.has(value.name)) {
+				return ok(`$.${value.name}`);
+			}
+			return err({
+				code: "GRAPHQL_UNDECLARED_VARIABLE",
+				message: `Variable "$${value.name}" is not declared in the operation`,
+				variableName: value.name
+			});
+		case "int":
+		case "float": return ok(value.value);
+		case "string": return ok(JSON.stringify(value.value));
+		case "boolean": return ok(value.value ? "true" : "false");
+		case "null": return ok("null");
+		case "enum": return ok(JSON.stringify(value.value));
+		case "list": {
+			const values = [];
+			for (const v of value.values) {
+				const result = emitValue(v, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				values.push(result.value);
+			}
+			return ok(`[${values.join(", ")}]`);
+		}
+		case "object": {
+			if (value.fields.length === 0) {
+				return ok("{}");
+			}
+			const entries = [];
+			for (const f of value.fields) {
+				const result = emitValue(f.value, variableNames);
+				if (result.isErr()) {
+					return err(result.error);
+				}
+				entries.push(`${f.name}: ${result.value}`);
+			}
+			return ok(`{ ${entries.join(", ")} }`);
+		}
+	}
+};
+
+//#endregion
+//#region packages/codegen/src/graphql-compat/parser.ts
+/**
+* Parser for .graphql operation files.
+* Extracts operations and fragments from GraphQL documents.
+* @module
+*/
+/**
+* Parse a single .graphql file and extract operations and fragments.
+*/
+const parseGraphqlFile = (filePath) => {
+	const resolvedPath = resolve(filePath);
+	if (!existsSync(resolvedPath)) {
+		return err({
+			code: "GRAPHQL_FILE_NOT_FOUND",
+			message: `GraphQL file not found at ${resolvedPath}`,
+			filePath: resolvedPath
+		});
+	}
+	try {
+		const source = readFileSync(resolvedPath, "utf8");
+		const document = parse(source);
+		return ok(extractFromDocument(document, resolvedPath));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "GRAPHQL_PARSE_ERROR",
+			message: `GraphQL parse error: ${message}`,
+			filePath: resolvedPath
+		});
+	}
+};
+/**
+* Parse GraphQL source string directly.
+*/
+const parseGraphqlSource = (source, sourceFile) => {
+	try {
+		const document = parse(source);
+		return ok(extractFromDocument(document, sourceFile));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		return err({
+			code: "GRAPHQL_PARSE_ERROR",
+			message: `GraphQL parse error: ${message}`,
+			filePath: sourceFile
+		});
+	}
+};
+/**
+* Extract operations and fragments from a parsed GraphQL document.
+*/
+const extractFromDocument = (document, sourceFile) => {
+	const operations = [];
+	const fragments = [];
+	for (const definition of document.definitions) {
+		if (definition.kind === Kind.OPERATION_DEFINITION) {
+			const operation = extractOperation(definition, sourceFile);
+			if (operation) {
+				operations.push(operation);
+			}
+		} else if (definition.kind === Kind.FRAGMENT_DEFINITION) {
+			fragments.push(extractFragment(definition, sourceFile));
+		}
+	}
+	return {
+		operations,
+		fragments
+	};
+};
+/**
+* Extract a single operation from an OperationDefinitionNode.
+*/
+const extractOperation = (node, sourceFile) => {
+	if (!node.name) {
+		return null;
+	}
+	const variables = (node.variableDefinitions ?? []).map(extractVariable);
+	const selections = extractSelections(node.selectionSet.selections);
+	return {
+		kind: node.operation,
+		name: node.name.value,
+		variables,
+		selections,
+		sourceFile
+	};
+};
+/**
+* Extract a fragment from a FragmentDefinitionNode.
+*/
+const extractFragment = (node, sourceFile) => {
+	const selections = extractSelections(node.selectionSet.selections);
+	return {
+		name: node.name.value,
+		onType: node.typeCondition.name.value,
+		selections,
+		sourceFile
+	};
+};
+/**
+* Extract a variable definition.
+*/
+const extractVariable = (node) => {
+	const { typeName, modifier } = parseTypeNode(node.type);
+	const defaultValue = node.defaultValue ? extractValue(node.defaultValue) : undefined;
+	return {
+		name: node.variable.name.value,
+		typeName,
+		modifier,
+		typeKind: "scalar",
+		defaultValue
+	};
+};
+/**
+* Parse a GraphQL TypeNode into type name and modifier.
+*
+* Format: inner nullability + list modifiers
+* - Inner: `!` (non-null) or `?` (nullable)
+* - List: `[]!` (non-null list) or `[]?` (nullable list)
+*/
+const parseTypeNode = (node) => {
+	const levels = [];
+	const collect = (n, nonNull) => {
+		if (n.kind === Kind.NON_NULL_TYPE) {
+			return collect(n.type, true);
+		}
+		if (n.kind === Kind.LIST_TYPE) {
+			levels.push({
+				kind: "list",
+				nonNull
+			});
+			return collect(n.type, false);
+		}
+		levels.push({
+			kind: "named",
+			nonNull
+		});
+		return n.name.value;
+	};
+	const typeName = collect(node, false);
+	let modifier = "?";
+	for (const level of levels.slice().reverse()) {
+		if (level.kind === "named") {
+			modifier = level.nonNull ? "!" : "?";
+			continue;
+		}
+		const listSuffix = level.nonNull ? "[]!" : "[]?";
+		modifier = `${modifier}${listSuffix}`;
+	}
+	return {
+		typeName,
+		modifier
+	};
+};
+/**
+* Extract selections from a SelectionSet.
+*/
+const extractSelections = (selections) => {
+	return selections.map(extractSelection);
+};
+/**
+* Extract a single selection.
+*/
+const extractSelection = (node) => {
+	switch (node.kind) {
+		case Kind.FIELD: return extractFieldSelection(node);
+		case Kind.FRAGMENT_SPREAD: return extractFragmentSpread(node);
+		case Kind.INLINE_FRAGMENT: return extractInlineFragment(node);
+	}
+};
+/**
+* Extract a field selection.
+*/
+const extractFieldSelection = (node) => {
+	const args = node.arguments?.length ? node.arguments.map(extractArgument) : undefined;
+	const selections = node.selectionSet ? extractSelections(node.selectionSet.selections) : undefined;
+	return {
+		kind: "field",
+		name: node.name.value,
+		alias: node.alias?.value,
+		arguments: args,
+		selections
+	};
+};
+/**
+* Extract a fragment spread.
+*/
+const extractFragmentSpread = (node) => {
+	return {
+		kind: "fragmentSpread",
+		name: node.name.value
+	};
+};
+/**
+* Extract an inline fragment.
+*/
+const extractInlineFragment = (node) => {
+	return {
+		kind: "inlineFragment",
+		onType: node.typeCondition?.name.value ?? "",
+		selections: extractSelections(node.selectionSet.selections)
+	};
+};
+/**
+* Extract an argument.
+*/
+const extractArgument = (node) => {
+	return {
+		name: node.name.value,
+		value: extractValue(node.value)
+	};
+};
+/**
+* Assert unreachable code path (for exhaustiveness checks).
+*/
+const assertUnreachable = (value) => {
+	throw new Error(`Unexpected value: ${JSON.stringify(value)}`);
+};
+/**
+* Extract a value (literal or variable reference).
+*/
+const extractValue = (node) => {
+	switch (node.kind) {
+		case Kind.VARIABLE: return {
+			kind: "variable",
+			name: node.name.value
+		};
+		case Kind.INT: return {
+			kind: "int",
+			value: node.value
+		};
+		case Kind.FLOAT: return {
+			kind: "float",
+			value: node.value
+		};
+		case Kind.STRING: return {
+			kind: "string",
+			value: node.value
+		};
+		case Kind.BOOLEAN: return {
+			kind: "boolean",
+			value: node.value
+		};
+		case Kind.NULL: return { kind: "null" };
+		case Kind.ENUM: return {
+			kind: "enum",
+			value: node.value
+		};
+		case Kind.LIST: return {
+			kind: "list",
+			values: node.values.map(extractValue)
+		};
+		case Kind.OBJECT: return {
+			kind: "object",
+			fields: node.fields.map((field) => ({
+				name: field.name.value,
+				value: extractValue(field.value)
+			}))
+		};
+		default: return assertUnreachable(node);
+	}
+};
+
+//#endregion
+//#region packages/codegen/src/graphql-compat/transformer.ts
+/**
+* Built-in GraphQL scalar types.
+*/
+const builtinScalarTypes = new Set([
+	"ID",
+	"String",
+	"Int",
+	"Float",
+	"Boolean"
+]);
+/**
+* Check if a type name is a scalar type.
+*/
+const isScalarName = (schema, name) => builtinScalarTypes.has(name) || schema.scalars.has(name);
+/**
+* Check if a type name is an enum type.
+*/
+const isEnumName = (schema, name) => schema.enums.has(name);
+/**
+* Transform parsed operations/fragments by enriching them with schema information.
+*
+* This resolves variable type kinds (scalar, enum, input) and collects
+* fragment dependencies.
+*/
+const transformParsedGraphql = (parsed, options) => {
+	const schema = createSchemaIndex(options.schemaDocument);
+	const operations = [];
+	for (const op of parsed.operations) {
+		const result = transformOperation(op, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		operations.push(result.value);
+	}
+	const fragments = [];
+	for (const frag of parsed.fragments) {
+		const result = transformFragment(frag, schema);
+		if (result.isErr()) {
+			return err(result.error);
+		}
+		fragments.push(result.value);
+	}
+	return ok({
+		operations,
+		fragments
+	});
+};
+/**
+* Transform a single operation.
+*/
+const transformOperation = (op, schema) => {
+	const variables = [];
+	for (const v of op.variables) {
+		const typeKind = resolveTypeKind(schema, v.typeName);
+		if (typeKind === null) {
+			return err({
+				code: "GRAPHQL_UNKNOWN_TYPE",
+				message: `Unknown type "${v.typeName}" in variable "${v.name}"`,
+				typeName: v.typeName
+			});
+		}
+		variables.push({
+			...v,
+			typeKind
+		});
+	}
+	const fragmentDependencies = collectFragmentDependencies(op.selections);
+	return ok({
+		...op,
+		variables,
+		fragmentDependencies
+	});
+};
+/**
+* Transform a single fragment.
+*/
+const transformFragment = (frag, _schema) => {
+	const fragmentDependencies = collectFragmentDependencies(frag.selections);
+	return ok({
+		...frag,
+		fragmentDependencies
+	});
+};
+/**
+* Resolve the type kind for a type name.
+*/
+const resolveTypeKind = (schema, typeName) => {
+	if (isScalarName(schema, typeName)) {
+		return "scalar";
+	}
+	if (isEnumName(schema, typeName)) {
+		return "enum";
+	}
+	if (schema.inputs.has(typeName)) {
+		return "input";
+	}
+	return null;
+};
+/**
+* Collect fragment names used in selections (recursively).
+*/
+const collectFragmentDependencies = (selections) => {
+	const fragments = new Set();
+	const collect = (sels) => {
+		for (const sel of sels) {
+			switch (sel.kind) {
+				case "fragmentSpread":
+					fragments.add(sel.name);
+					break;
+				case "field":
+					if (sel.selections) {
+						collect(sel.selections);
+					}
+					break;
+				case "inlineFragment":
+					collect(sel.selections);
+					break;
+			}
+		}
+	};
+	collect(selections);
+	return [...fragments];
+};
+
+//#endregion
 //#region packages/codegen/src/inject-template.ts
 const templateContents = `\
 import { defineScalar } from "@soda-gql/core";
@@ -73,6 +737,170 @@ const esbuildBundler = {
 	}
 };
 
+//#endregion
+//#region packages/codegen/src/defs-generator.ts
+/**
+* Split an array into chunks of the specified size.
+*/
+const chunkArray = (array, size) => {
+	if (size <= 0) {
+		return [Array.from(array)];
+	}
+	const result = [];
+	for (let i = 0; i < array.length; i += size) {
+		result.push(array.slice(i, i + size));
+	}
+	return result;
+};
+/**
+* Determine if chunking is needed based on the number of definitions.
+*/
+const needsChunking = (vars, chunkSize) => {
+	return vars.length > chunkSize;
+};
+/**
+* Generate a single definition file content.
+*/
+const generateDefinitionFile = (options) => {
+	const { category, vars, needsDefineEnum } = options;
+	if (vars.length === 0) {
+		return `/**
+ * ${category} definitions (empty)
+ * @generated by @soda-gql/codegen
+ */
+`;
+	}
+	const imports = [];
+	if (needsDefineEnum && category === "enums") {
+		imports.push("import { defineEnum } from \"@soda-gql/core\";");
+	}
+	const importsBlock = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+	const exportStatements = vars.map((v) => `export ${v.code}`).join("\n");
+	return `/**
+ * ${category} definitions
+ * @generated by @soda-gql/codegen
+ */
+${importsBlock}${exportStatements}
+`;
+};
+/**
+* Generate a chunk file content.
+*/
+const generateChunkFile = (options) => {
+	const { category, vars, chunkIndex, needsDefineEnum } = options;
+	if (vars.length === 0) {
+		return `/**
+ * ${category} chunk ${chunkIndex} (empty)
+ * @generated by @soda-gql/codegen
+ */
+`;
+	}
+	const imports = [];
+	if (needsDefineEnum && category === "enums") {
+		imports.push("import { defineEnum } from \"@soda-gql/core\";");
+	}
+	const importsBlock = imports.length > 0 ? `${imports.join("\n")}\n\n` : "";
+	const exportStatements = vars.map((v) => `export ${v.code}`).join("\n");
+	return `/**
+ * ${category} chunk ${chunkIndex}
+ * @generated by @soda-gql/codegen
+ */
+${importsBlock}${exportStatements}
+`;
+};
+/**
+* Generate the index file that re-exports all chunks.
+*/
+const generateChunkIndex = (options) => {
+	const { category, chunkCount } = options;
+	const reExports = Array.from({ length: chunkCount }, (_, i) => `export * from "./chunk-${i}";`).join("\n");
+	return `/**
+ * ${category} index (re-exports all chunks)
+ * @generated by @soda-gql/codegen
+ */
+${reExports}
+`;
+};
+/**
+* Generate chunked definition files.
+*/
+const generateChunkedDefinitionFiles = (category, schemaName, vars, chunkSize) => {
+	const chunks = chunkArray(vars, chunkSize);
+	const needsDefineEnum = category === "enums";
+	const chunkContents = chunks.map((chunkVars, chunkIndex) => ({
+		chunkIndex,
+		content: generateChunkFile({
+			category,
+			schemaName,
+			vars: chunkVars,
+			chunkIndex,
+			needsDefineEnum
+		}),
+		varNames: chunkVars.map((v) => v.name)
+	}));
+	const allVarNames = vars.map((v) => v.name);
+	const indexContent = generateChunkIndex({
+		category,
+		chunkCount: chunks.length,
+		varNames: allVarNames
+	});
+	return {
+		indexContent,
+		chunks: chunkContents
+	};
+};
+/**
+* Generate the complete _defs directory structure.
+*/
+const generateDefsStructure = (schemaName, categoryVars, chunkSize) => {
+	const files = [];
+	const importPaths = {
+		enums: "./_defs/enums",
+		inputs: "./_defs/inputs",
+		objects: "./_defs/objects",
+		unions: "./_defs/unions"
+	};
+	const categories = [
+		"enums",
+		"inputs",
+		"objects",
+		"unions"
+	];
+	for (const category of categories) {
+		const vars = categoryVars[category];
+		const needsDefineEnum = category === "enums";
+		if (needsChunking(vars, chunkSize)) {
+			const chunked = generateChunkedDefinitionFiles(category, schemaName, vars, chunkSize);
+			importPaths[category] = `./_defs/${category}`;
+			files.push({
+				relativePath: `_defs/${category}/index.ts`,
+				content: chunked.indexContent
+			});
+			for (const chunk of chunked.chunks) {
+				files.push({
+					relativePath: `_defs/${category}/chunk-${chunk.chunkIndex}.ts`,
+					content: chunk.content
+				});
+			}
+		} else {
+			const content = generateDefinitionFile({
+				category,
+				schemaName,
+				vars,
+				needsDefineEnum
+			});
+			files.push({
+				relativePath: `_defs/${category}.ts`,
+				content
+			});
+		}
+	}
+	return {
+		files,
+		importPaths
+	};
+};
+
 //#endregion
 //#region packages/codegen/src/file.ts
 const writeModule = (outPath, contents) => {
@@ -226,10 +1054,12 @@ const runCodegen = async (options) => {
 			inputDepthOverridesConfig.set(schemaName, schemaConfig.inputDepthOverrides);
 		}
 	}
-	const { code: internalCode, injectsCode } = generateMultiSchemaModule(schemas, {
+	const chunkSize = options.chunkSize ?? 100;
+	const { code: internalCode, injectsCode, categoryVars } = generateMultiSchemaModule(schemas, {
 		injection: injectionConfig,
 		defaultInputDepth: defaultInputDepthConfig.size > 0 ? defaultInputDepthConfig : undefined,
-		inputDepthOverrides: inputDepthOverridesConfig.size > 0 ? inputDepthOverridesConfig : undefined
+		inputDepthOverrides: inputDepthOverridesConfig.size > 0 ? inputDepthOverridesConfig : undefined,
+		chunkSize
 	});
 	const indexCode = `/**
  * Generated by @soda-gql/codegen
@@ -239,7 +1069,7 @@ const runCodegen = async (options) => {
 export * from "./_internal";
 `;
 	for (const [name, document] of schemas.entries()) {
-		const schemaIndex = (await import("./generator-D6nHdJ1K.mjs")).createSchemaIndex(document);
+		const schemaIndex = (await import("./generator--76HN3Ud.mjs")).createSchemaIndex(document);
 		const objects = Array.from(schemaIndex.objects.keys()).filter((n) => !n.startsWith("__")).length;
 		const enums = Array.from(schemaIndex.enums.keys()).filter((n) => !n.startsWith("__")).length;
 		const inputs = Array.from(schemaIndex.inputs.keys()).filter((n) => !n.startsWith("__")).length;
@@ -259,6 +1089,31 @@ export * from "./_internal";
 			return err(injectsWriteResult.error);
 		}
 	}
+	const defsPaths = [];
+	if (categoryVars) {
+		const outDir = dirname(outPath);
+		const combinedVars = {
+			enums: [],
+			inputs: [],
+			objects: [],
+			unions: []
+		};
+		for (const vars of Object.values(categoryVars)) {
+			combinedVars.enums.push(...vars.enums);
+			combinedVars.inputs.push(...vars.inputs);
+			combinedVars.objects.push(...vars.objects);
+			combinedVars.unions.push(...vars.unions);
+		}
+		const defsStructure = generateDefsStructure("combined", combinedVars, chunkSize);
+		for (const file of defsStructure.files) {
+			const filePath = join(outDir, file.relativePath);
+			const writeResult = await writeModule(filePath, file.content).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
+			if (writeResult.isErr()) {
+				return err(writeResult.error);
+			}
+			defsPaths.push(filePath);
+		}
+	}
 	const internalPath = join(dirname(outPath), "_internal.ts");
 	const internalWriteResult = await writeModule(internalPath, internalCode).match(() => Promise.resolve(ok(undefined)), (error) => Promise.resolve(err(error)));
 	if (internalWriteResult.isErr()) {
@@ -281,10 +1136,11 @@ export * from "./_internal";
 		outPath,
 		internalPath,
 		injectsPath,
-		cjsPath: bundleResult.value.cjsPath
+		cjsPath: bundleResult.value.cjsPath,
+		...defsPaths.length > 0 ? { defsPaths } : {}
 	});
 };
 
 //#endregion
-export { hashSchema, loadSchema, runCodegen, writeInjectTemplate };
+export { emitFragment, emitOperation, hashSchema, loadSchema, parseGraphqlFile, parseGraphqlSource, parseTypeNode, runCodegen, transformParsedGraphql, writeInjectTemplate };
 //# sourceMappingURL=index.mjs.map