@soda-gql/codegen 0.11.12 → 0.11.14

package/dist/generator-DvfP6gTY.cjs

@@ -1,771 +0,0 @@
-let graphql = require("graphql");
-
-//#region packages/codegen/src/generator.ts
-const builtinScalarTypes = new Map([
-	["ID", {
-		input: "string",
-		output: "string"
-	}],
-	["String", {
-		input: "string",
-		output: "string"
-	}],
-	["Int", {
-		input: "number",
-		output: "number"
-	}],
-	["Float", {
-		input: "number",
-		output: "number"
-	}],
-	["Boolean", {
-		input: "boolean",
-		output: "boolean"
-	}]
-]);
-const ensureRecord = (collection, key, factory) => {
-	const existing = collection.get(key);
-	if (existing) {
-		return existing;
-	}
-	const created = factory(key);
-	collection.set(key, created);
-	return created;
-};
-const addObjectFields = (target, fields) => {
-	if (!fields) {
-		return;
-	}
-	for (const field of fields) {
-		target.set(field.name.value, field);
-	}
-};
-const addInputFields = (target, fields) => {
-	if (!fields) {
-		return;
-	}
-	for (const field of fields) {
-		target.set(field.name.value, field);
-	}
-};
-const addEnumValues = (target, values) => {
-	if (!values) {
-		return;
-	}
-	for (const value of values) {
-		target.set(value.name.value, value);
-	}
-};
-const addUnionMembers = (target, members) => {
-	if (!members) {
-		return;
-	}
-	for (const member of members) {
-		target.set(member.name.value, member);
-	}
-};
-const mergeDirectives = (existing, incoming, precedence) => {
-	const current = existing ?? [];
-	const next = incoming ? Array.from(incoming) : [];
-	return precedence === "definition" ? [...next, ...current] : [...current, ...next];
-};
-const updateOperationTypes = (operationTypes, definition) => {
-	for (const operation of definition.operationTypes ?? []) {
-		const typeName = operation.type.name.value;
-		switch (operation.operation) {
-			case "query":
-				operationTypes.query = typeName;
-				break;
-			case "mutation":
-				operationTypes.mutation = typeName;
-				break;
-			case "subscription":
-				operationTypes.subscription = typeName;
-				break;
-			default: break;
-		}
-	}
-};
-const addDirectiveArgs = (target, args) => {
-	if (!args) {
-		return;
-	}
-	for (const arg of args) {
-		target.set(arg.name.value, arg);
-	}
-};
-const createSchemaIndex = (document) => {
-	const objects = new Map();
-	const inputs = new Map();
-	const enums = new Map();
-	const unions = new Map();
-	const scalars = new Map();
-	const directives = new Map();
-	const operationTypes = {};
-	for (const definition of document.definitions) {
-		switch (definition.kind) {
-			case graphql.Kind.OBJECT_TYPE_DEFINITION:
-			case graphql.Kind.OBJECT_TYPE_EXTENSION: {
-				const precedence = definition.kind === graphql.Kind.OBJECT_TYPE_DEFINITION ? "definition" : "extension";
-				const record = ensureRecord(objects, definition.name.value, (name) => ({
-					name,
-					fields: new Map(),
-					directives: []
-				}));
-				addObjectFields(record.fields, definition.fields);
-				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
-				break;
-			}
-			case graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION:
-			case graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION: {
-				const precedence = definition.kind === graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION ? "definition" : "extension";
-				const record = ensureRecord(inputs, definition.name.value, (name) => ({
-					name,
-					fields: new Map(),
-					directives: []
-				}));
-				addInputFields(record.fields, definition.fields);
-				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
-				break;
-			}
-			case graphql.Kind.ENUM_TYPE_DEFINITION:
-			case graphql.Kind.ENUM_TYPE_EXTENSION: {
-				const precedence = definition.kind === graphql.Kind.ENUM_TYPE_DEFINITION ? "definition" : "extension";
-				const record = ensureRecord(enums, definition.name.value, (name) => ({
-					name,
-					values: new Map(),
-					directives: []
-				}));
-				addEnumValues(record.values, definition.values);
-				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
-				break;
-			}
-			case graphql.Kind.UNION_TYPE_DEFINITION:
-			case graphql.Kind.UNION_TYPE_EXTENSION: {
-				const precedence = definition.kind === graphql.Kind.UNION_TYPE_DEFINITION ? "definition" : "extension";
-				const record = ensureRecord(unions, definition.name.value, (name) => ({
-					name,
-					members: new Map(),
-					directives: []
-				}));
-				addUnionMembers(record.members, definition.types);
-				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
-				break;
-			}
-			case graphql.Kind.SCALAR_TYPE_DEFINITION:
-			case graphql.Kind.SCALAR_TYPE_EXTENSION: {
-				const precedence = definition.kind === graphql.Kind.SCALAR_TYPE_DEFINITION ? "definition" : "extension";
-				const record = ensureRecord(scalars, definition.name.value, (name) => ({
-					name,
-					directives: []
-				}));
-				record.directives = mergeDirectives(record.directives, definition.directives, precedence);
-				break;
-			}
-			case graphql.Kind.DIRECTIVE_DEFINITION: {
-				const name = definition.name.value;
-				if (name === "skip" || name === "include" || name === "deprecated" || name === "specifiedBy") {
-					break;
-				}
-				const args = new Map();
-				addDirectiveArgs(args, definition.arguments);
-				directives.set(name, {
-					name,
-					locations: definition.locations.map((loc) => loc.value),
-					args,
-					isRepeatable: definition.repeatable
-				});
-				break;
-			}
-			case graphql.Kind.SCHEMA_DEFINITION:
-			case graphql.Kind.SCHEMA_EXTENSION:
-				updateOperationTypes(operationTypes, definition);
-				break;
-			default: break;
-		}
-	}
-	if (!operationTypes.query && objects.has("Query")) {
-		operationTypes.query = "Query";
-	}
-	if (!operationTypes.mutation && objects.has("Mutation")) {
-		operationTypes.mutation = "Mutation";
-	}
-	if (!operationTypes.subscription && objects.has("Subscription")) {
-		operationTypes.subscription = "Subscription";
-	}
-	return {
-		objects,
-		inputs,
-		enums,
-		unions,
-		scalars,
-		directives,
-		operationTypes
-	};
-};
-const collectTypeLevels = (type, nonNull = false, levels = []) => {
-	if (type.kind === graphql.Kind.NON_NULL_TYPE) {
-		return collectTypeLevels(type.type, true, levels);
-	}
-	if (type.kind === graphql.Kind.LIST_TYPE) {
-		levels.push({
-			kind: "list",
-			nonNull
-		});
-		return collectTypeLevels(type.type, false, levels);
-	}
-	levels.push({
-		kind: "named",
-		nonNull
-	});
-	return {
-		name: type.name.value,
-		levels
-	};
-};
-const buildTypeModifier = (levels) => {
-	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 modifier;
-};
-const parseTypeReference = (type) => {
-	const { name, levels } = collectTypeLevels(type);
-	return {
-		name,
-		modifier: buildTypeModifier(levels)
-	};
-};
-const isScalarName = (schema, name) => builtinScalarTypes.has(name) || schema.scalars.has(name);
-const isEnumName = (schema, name) => schema.enums.has(name);
-const _isInputName = (schema, name) => schema.inputs.has(name);
-const isUnionName = (schema, name) => schema.unions.has(name);
-const isObjectName = (schema, name) => schema.objects.has(name);
-const renderConstValue = (value) => {
-	switch (value.kind) {
-		case graphql.Kind.NULL: return "null";
-		case graphql.Kind.INT:
-		case graphql.Kind.FLOAT: return value.value;
-		case graphql.Kind.STRING:
-		case graphql.Kind.ENUM: return JSON.stringify(value.value);
-		case graphql.Kind.BOOLEAN: return value.value ? "true" : "false";
-		case graphql.Kind.LIST: return `[${value.values.map((item) => renderConstValue(item)).join(", ")}]`;
-		case graphql.Kind.OBJECT: {
-			if (value.fields.length === 0) {
-				return "{}";
-			}
-			const entries = value.fields.map((field) => `${field.name.value}: ${renderConstValue(field.value)}`);
-			return `{ ${entries.join(", ")} }`;
-		}
-	}
-};
-const renderInputRef = (schema, definition) => {
-	const { name, modifier } = parseTypeReference(definition.type);
-	const defaultValue = definition.defaultValue;
-	let kind;
-	if (isScalarName(schema, name)) {
-		kind = "scalar";
-	} else if (isEnumName(schema, name)) {
-		kind = "enum";
-	} else {
-		kind = "input";
-	}
-	if (defaultValue) {
-		return `{ kind: "${kind}", name: "${name}", modifier: "${modifier}", defaultValue: { default: ${renderConstValue(defaultValue)} } }`;
-	}
-	return `{ kind: "${kind}", name: "${name}", modifier: "${modifier}" }`;
-};
-const renderArgumentMap = (schema, args) => {
-	const entries = [...args ?? []].sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => `${arg.name.value}: ${renderInputRef(schema, arg)}`);
-	return renderPropertyLines({
-		entries,
-		indentSize: 8
-	});
-};
-const renderOutputRef = (schema, type, args) => {
-	const { name, modifier } = parseTypeReference(type);
-	const argumentMap = renderArgumentMap(schema, args);
-	let kind;
-	if (isScalarName(schema, name)) {
-		kind = "scalar";
-	} else if (isEnumName(schema, name)) {
-		kind = "enum";
-	} else if (isUnionName(schema, name)) {
-		kind = "union";
-	} else if (isObjectName(schema, name)) {
-		kind = "object";
-	} else {
-		kind = "scalar";
-	}
-	return `{ kind: "${kind}", name: "${name}", modifier: "${modifier}", arguments: ${argumentMap} }`;
-};
-const renderPropertyLines = ({ entries, indentSize }) => {
-	if (entries.length === 0) {
-		return "{}";
-	}
-	const indent = " ".repeat(indentSize);
-	const lastIndent = " ".repeat(indentSize - 2);
-	return [
-		"{",
-		`${indent}${entries.join(`,\n${indent}`)},`,
-		`${lastIndent}}`
-	].join(`\n`);
-};
-const renderObjectFields = (schema, fields) => {
-	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderOutputRef(schema, field.type, field.arguments)}`);
-	return renderPropertyLines({
-		entries,
-		indentSize: 6
-	});
-};
-const renderInputFields = (schema, fields) => {
-	const entries = Array.from(fields.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((field) => `${field.name.value}: ${renderInputRef(schema, field)}`);
-	return renderPropertyLines({
-		entries,
-		indentSize: 6
-	});
-};
-const renderScalarVar = (schemaName, record) => {
-	const typeInfo = builtinScalarTypes.get(record.name) ?? {
-		input: "string",
-		output: "string"
-	};
-	return `const scalar_${schemaName}_${record.name} = { name: "${record.name}", $type: {} as { input: ${typeInfo.input}; output: ${typeInfo.output}; inputProfile: { kind: "scalar"; name: "${record.name}"; value: ${typeInfo.input} }; outputProfile: { kind: "scalar"; name: "${record.name}"; value: ${typeInfo.output} } } } as const;`;
-};
-const renderEnumVar = (schemaName, record) => {
-	const valueNames = Array.from(record.values.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((value) => value.name.value);
-	const valuesObj = valueNames.length === 0 ? "{}" : `{ ${valueNames.map((v) => `${v}: true`).join(", ")} }`;
-	const valueUnion = valueNames.length === 0 ? "never" : valueNames.map((v) => `"${v}"`).join(" | ");
-	return `const enum_${schemaName}_${record.name} = defineEnum<"${record.name}", ${valueUnion}>("${record.name}", ${valuesObj});`;
-};
-const renderInputVar = (schemaName, schema, record) => {
-	const fields = renderInputFields(schema, record.fields);
-	return `const input_${schemaName}_${record.name} = { name: "${record.name}", fields: ${fields} } as const;`;
-};
-const renderObjectVar = (schemaName, schema, record) => {
-	const fields = renderObjectFields(schema, record.fields);
-	return `const object_${schemaName}_${record.name} = { name: "${record.name}", fields: ${fields} } as const;`;
-};
-const renderUnionVar = (schemaName, record) => {
-	const memberNames = Array.from(record.members.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((member) => member.name.value);
-	const typesObj = memberNames.length === 0 ? "{}" : `{ ${memberNames.map((m) => `${m}: true`).join(", ")} }`;
-	return `const union_${schemaName}_${record.name} = { name: "${record.name}", types: ${typesObj} } as const;`;
-};
-const collectObjectTypeNames = (schema) => Array.from(schema.objects.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const renderFragmentBuildersType = (objectTypeNames, schemaName, adapterTypeName) => {
-	if (objectTypeNames.length === 0) {
-		return `type FragmentBuilders_${schemaName} = Record<string, never>;`;
-	}
-	const adapterPart = adapterTypeName ? `, ExtractMetadataAdapter<${adapterTypeName}>` : "";
-	const entries = objectTypeNames.map((name) => `  readonly ${name}: FragmentBuilderFor<Schema_${schemaName}, "${name}"${adapterPart}>`);
-	return `type FragmentBuilders_${schemaName} = {\n${entries.join(";\n")};\n};`;
-};
-const collectInputTypeNames = (schema) => Array.from(schema.inputs.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const collectEnumTypeNames = (schema) => Array.from(schema.enums.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const collectUnionTypeNames = (schema) => Array.from(schema.unions.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const collectScalarNames = (schema) => Array.from(schema.scalars.keys()).filter((name) => !name.startsWith("__")).sort((left, right) => left.localeCompare(right));
-const collectDirectiveNames = (schema) => Array.from(schema.directives.keys()).sort((left, right) => left.localeCompare(right));
-const renderInputTypeMethod = (factoryVar, kind, typeName) => `${typeName}: ${factoryVar}("${kind}", "${typeName}")`;
-const renderInputTypeMethods = (schema, factoryVar) => {
-	const scalarMethods = Array.from(builtinScalarTypes.keys()).concat(collectScalarNames(schema).filter((name) => !builtinScalarTypes.has(name))).map((name) => renderInputTypeMethod(factoryVar, "scalar", name));
-	const enumMethods = collectEnumTypeNames(schema).map((name) => renderInputTypeMethod(factoryVar, "enum", name));
-	const inputMethods = collectInputTypeNames(schema).map((name) => renderInputTypeMethod(factoryVar, "input", name));
-	const allMethods = [
-		...scalarMethods,
-		...enumMethods,
-		...inputMethods
-	].sort((left, right) => {
-		const leftName = left.split(":")[0] ?? "";
-		const rightName = right.split(":")[0] ?? "";
-		return leftName.localeCompare(rightName);
-	});
-	return renderPropertyLines({
-		entries: allMethods,
-		indentSize: 2
-	});
-};
-/**
-* Renders argument specifiers for a directive.
-* Returns null if the directive has no arguments.
-*/
-const renderDirectiveArgsSpec = (schema, args) => {
-	if (args.size === 0) return null;
-	const entries = Array.from(args.values()).sort((left, right) => left.name.value.localeCompare(right.name.value)).map((arg) => `${arg.name.value}: ${renderInputRef(schema, arg)}`);
-	return renderPropertyLines({
-		entries,
-		indentSize: 4
-	});
-};
-const renderDirectiveMethod = (schema, record) => {
-	const locationsJson = JSON.stringify(record.locations);
-	const argsSpec = renderDirectiveArgsSpec(schema, record.args);
-	if (argsSpec === null) {
-		return `${record.name}: createDirectiveMethod("${record.name}", ${locationsJson} as const)`;
-	}
-	return `${record.name}: createTypedDirectiveMethod("${record.name}", ${locationsJson} as const, ${argsSpec})`;
-};
-const renderDirectiveMethods = (schema) => {
-	const directiveNames = collectDirectiveNames(schema);
-	if (directiveNames.length === 0) {
-		return "{}";
-	}
-	const methods = directiveNames.map((name) => {
-		const record = schema.directives.get(name);
-		return record ? renderDirectiveMethod(schema, record) : null;
-	}).filter((method) => method !== null);
-	return renderPropertyLines({
-		entries: methods,
-		indentSize: 2
-	});
-};
-/**
-* Generates the _internal-injects.ts module code.
-* This file contains only adapter imports (scalar, adapter) to keep it lightweight.
-* The heavy schema types remain in _internal.ts.
-*/
-const generateInjectsCode = (injection) => {
-	const imports = [];
-	const exports$1 = [];
-	const typeExports = [];
-	const importsByPath = new Map();
-	for (const [schemaName, config] of injection) {
-		const scalarAlias = `scalar_${schemaName}`;
-		const scalarSpecifiers = importsByPath.get(config.scalarImportPath) ?? [];
-		if (!importsByPath.has(config.scalarImportPath)) {
-			importsByPath.set(config.scalarImportPath, scalarSpecifiers);
-		}
-		scalarSpecifiers.push(`scalar as ${scalarAlias}`);
-		exports$1.push(`export { ${scalarAlias} };`);
-		typeExports.push(`export type Scalar_${schemaName} = typeof ${scalarAlias};`);
-		if (config.adapterImportPath) {
-			const adapterAlias = `adapter_${schemaName}`;
-			const adapterSpecifiers = importsByPath.get(config.adapterImportPath) ?? [];
-			if (!importsByPath.has(config.adapterImportPath)) {
-				importsByPath.set(config.adapterImportPath, adapterSpecifiers);
-			}
-			adapterSpecifiers.push(`adapter as ${adapterAlias}`);
-			exports$1.push(`export { ${adapterAlias} };`);
-			typeExports.push(`export type Adapter_${schemaName} = typeof ${adapterAlias} & { _?: never };`);
-		}
-	}
-	for (const [path, specifiers] of importsByPath) {
-		if (specifiers.length === 1) {
-			imports.push(`import { ${specifiers[0]} } from "${path}";`);
-		} else {
-			imports.push(`import {\n  ${specifiers.join(",\n  ")},\n} from "${path}";`);
-		}
-	}
-	return `\
-/**
- * Adapter injections for schema.
- * Separated to allow lightweight imports for prebuilt module.
- * @generated by @soda-gql/codegen
- */
-
-${imports.join("\n")}
-
-// Value exports
-${exports$1.join("\n")}
-
-// Type exports
-${typeExports.join("\n")}
-`;
-};
-const multiRuntimeTemplate = ($$) => {
-	const imports = [];
-	const scalarAliases = new Map();
-	const adapterAliases = new Map();
-	if ($$.injection.mode === "inject") {
-		const injectsImports = [];
-		for (const [schemaName, injection] of $$.injection.perSchema) {
-			const scalarAlias = `scalar_${schemaName}`;
-			scalarAliases.set(schemaName, scalarAlias);
-			injectsImports.push(scalarAlias);
-			if (injection.adapterImportPath) {
-				const adapterAlias = `adapter_${schemaName}`;
-				adapterAliases.set(schemaName, adapterAlias);
-				injectsImports.push(adapterAlias);
-			}
-		}
-		imports.push(`import { ${injectsImports.join(", ")} } from "${$$.injection.injectsModulePath}";`);
-	}
-	{
-		const { importPaths } = $$.splitting;
-		for (const [name, config] of Object.entries($$.schemas)) {
-			if (config.enumNames.length > 0) {
-				const enumImports = config.enumNames.map((n) => `enum_${name}_${n}`).join(", ");
-				imports.push(`import { ${enumImports} } from "${importPaths.enums}";`);
-			}
-			if (config.inputNames.length > 0) {
-				const inputImports = config.inputNames.map((n) => `input_${name}_${n}`).join(", ");
-				imports.push(`import { ${inputImports} } from "${importPaths.inputs}";`);
-			}
-			if (config.objectNames.length > 0) {
-				const objectImports = config.objectNames.map((n) => `object_${name}_${n}`).join(", ");
-				imports.push(`import { ${objectImports} } from "${importPaths.objects}";`);
-			}
-			if (config.unionNames.length > 0) {
-				const unionImports = config.unionNames.map((n) => `union_${name}_${n}`).join(", ");
-				imports.push(`import { ${unionImports} } from "${importPaths.unions}";`);
-			}
-		}
-	}
-	const extraImports = imports.length > 0 ? `${imports.join("\n")}\n` : "";
-	const schemaBlocks = [];
-	const gqlEntries = [];
-	for (const [name, config] of Object.entries($$.schemas)) {
-		const schemaVar = `${name}Schema`;
-		const adapterVar = adapterAliases.get(name);
-		const typeExports = [`export type Schema_${name} = typeof ${schemaVar} & { _?: never };`];
-		if (adapterVar) {
-			typeExports.push(`export type Adapter_${name} = typeof ${adapterVar} & { _?: never };`);
-		}
-		typeExports.push(config.fragmentBuildersTypeBlock);
-		const inputTypeMethodsVar = `inputTypeMethods_${name}`;
-		const factoryVar = `createMethod_${name}`;
-		const customDirectivesVar = `customDirectives_${name}`;
-		const defaultDepthBlock = config.defaultInputDepth !== undefined && config.defaultInputDepth !== 3 ? `\n  __defaultInputDepth: ${config.defaultInputDepth},` : "";
-		const depthOverridesBlock = config.inputDepthOverrides && Object.keys(config.inputDepthOverrides).length > 0 ? `\n  __inputDepthOverrides: ${JSON.stringify(config.inputDepthOverrides)},` : "";
-		const isSplitMode = true;
-		const scalarVarsBlock = config.scalarVars.join("\n");
-		const enumVarsBlock = isSplitMode ? "// (enums imported)" : config.enumVars.length > 0 ? config.enumVars.join("\n") : "// (no enums)";
-		const inputVarsBlock = isSplitMode ? "// (inputs imported)" : config.inputVars.length > 0 ? config.inputVars.join("\n") : "// (no inputs)";
-		const objectVarsBlock = isSplitMode ? "// (objects imported)" : config.objectVars.length > 0 ? config.objectVars.join("\n") : "// (no objects)";
-		const unionVarsBlock = isSplitMode ? "// (unions imported)" : config.unionVars.length > 0 ? config.unionVars.join("\n") : "// (no unions)";
-		const scalarAssembly = $$.injection.mode === "inject" ? scalarAliases.get(name) ?? "{}" : config.scalarNames.length > 0 ? `{ ${config.scalarNames.map((n) => `${n}: scalar_${name}_${n}`).join(", ")} }` : "{}";
-		const enumAssembly = config.enumNames.length > 0 ? `{ ${config.enumNames.map((n) => `${n}: enum_${name}_${n}`).join(", ")} }` : "{}";
-		const inputAssembly = config.inputNames.length > 0 ? `{ ${config.inputNames.map((n) => `${n}: input_${name}_${n}`).join(", ")} }` : "{}";
-		const objectAssembly = config.objectNames.length > 0 ? `{ ${config.objectNames.map((n) => `${n}: object_${name}_${n}`).join(", ")} }` : "{}";
-		const unionAssembly = config.unionNames.length > 0 ? `{ ${config.unionNames.map((n) => `${n}: union_${name}_${n}`).join(", ")} }` : "{}";
-		const scalarVarsSection = $$.injection.mode === "inject" ? "// (scalars imported)" : scalarVarsBlock;
-		const scalarAssemblyLine = $$.injection.mode === "inject" ? `// scalar_${name} is imported directly` : `const scalar_${name} = ${scalarAssembly} as const;`;
-		const scalarRef = $$.injection.mode === "inject" ? scalarAliases.get(name) ?? `scalar_${name}` : `scalar_${name}`;
-		schemaBlocks.push(`
-// Individual scalar definitions
-${scalarVarsSection}
-
-// Individual enum definitions
-${enumVarsBlock}
-
-// Individual input definitions
-${inputVarsBlock}
-
-// Individual object definitions
-${objectVarsBlock}
-
-// Individual union definitions
-${unionVarsBlock}
-
-// Category assembly
-${scalarAssemblyLine}
-const enum_${name} = ${enumAssembly} as const;
-const input_${name} = ${inputAssembly} as const;
-const object_${name} = ${objectAssembly} as const;
-const union_${name} = ${unionAssembly} as const;
-
-// Schema assembly
-const ${schemaVar} = {
-  label: "${name}" as const,
-  operations: { query: "${config.queryType}", mutation: "${config.mutationType}", subscription: "${config.subscriptionType}" } as const,
-  scalar: ${scalarRef},
-  enum: enum_${name},
-  input: input_${name},
-  object: object_${name},
-  union: union_${name},${defaultDepthBlock}${depthOverridesBlock}
-} as const;
-
-const ${factoryVar} = createVarMethodFactory<typeof ${schemaVar}>();
-const ${inputTypeMethodsVar} = ${config.inputTypeMethodsBlock};
-const ${customDirectivesVar} = { ...createStandardDirectives(), ...${config.directiveMethodsBlock} };
-
-${typeExports.join("\n")}`);
-		const gqlVarName = `gql_${name}`;
-		if (adapterVar) {
-			const typeParams = `<Schema_${name}, FragmentBuilders_${name}, typeof ${customDirectivesVar}, Adapter_${name}>`;
-			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { adapter: ${adapterVar}, inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
-		} else {
-			const typeParams = `<Schema_${name}, FragmentBuilders_${name}, typeof ${customDirectivesVar}>`;
-			schemaBlocks.push(`const ${gqlVarName} = createGqlElementComposer${typeParams}(${schemaVar}, { inputTypeMethods: ${inputTypeMethodsVar}, directiveMethods: ${customDirectivesVar} });`);
-		}
-		schemaBlocks.push(`export type Context_${name} = Parameters<typeof ${gqlVarName}>[0] extends (ctx: infer C) => unknown ? C : never;`);
-		const prebuiltExports = [
-			`export { ${schemaVar} as __schema_${name} }`,
-			`export { ${inputTypeMethodsVar} as __inputTypeMethods_${name} }`,
-			`export { ${customDirectivesVar} as __directiveMethods_${name} }`
-		];
-		if (adapterVar) {
-			prebuiltExports.push(`export { ${adapterVar} as __adapter_${name} }`);
-		}
-		schemaBlocks.push(`${prebuiltExports.join(";\n")};`);
-		gqlEntries.push(`  ${name}: ${gqlVarName}`);
-	}
-	const needsDefineEnum = false;
-	return `\
-import {${needsDefineEnum ? "\n  defineEnum," : ""}
-  type ExtractMetadataAdapter,
-  type FragmentBuilderFor,
-  createDirectiveMethod,
-  createTypedDirectiveMethod,
-  createGqlElementComposer,
-  createStandardDirectives,
-  createVarMethodFactory,
-} from "@soda-gql/core";
-${extraImports}
-${schemaBlocks.join("\n")}
-
-export const gql = {
-${gqlEntries.join(",\n")}
-};
-`;
-};
-const generateMultiSchemaModule = (schemas, options) => {
-	const schemaConfigs = {};
-	const allStats = {
-		objects: 0,
-		enums: 0,
-		inputs: 0,
-		unions: 0
-	};
-	for (const [name, document] of schemas.entries()) {
-		const schema = createSchemaIndex(document);
-		const objectTypeNames = collectObjectTypeNames(schema);
-		const enumTypeNames = collectEnumTypeNames(schema);
-		const inputTypeNames = collectInputTypeNames(schema);
-		const unionTypeNames = collectUnionTypeNames(schema);
-		const customScalarNames = collectScalarNames(schema).filter((n) => !builtinScalarTypes.has(n));
-		const scalarVars = [];
-		const enumVars = [];
-		const inputVars = [];
-		const objectVars = [];
-		const unionVars = [];
-		for (const scalarName of builtinScalarTypes.keys()) {
-			const record = schema.scalars.get(scalarName) ?? {
-				name: scalarName,
-				directives: []
-			};
-			scalarVars.push(renderScalarVar(name, record));
-		}
-		for (const scalarName of customScalarNames) {
-			const record = schema.scalars.get(scalarName);
-			if (record) {
-				scalarVars.push(renderScalarVar(name, record));
-			}
-		}
-		for (const enumName of enumTypeNames) {
-			const record = schema.enums.get(enumName);
-			if (record) {
-				enumVars.push(renderEnumVar(name, record));
-			}
-		}
-		for (const inputName of inputTypeNames) {
-			const record = schema.inputs.get(inputName);
-			if (record) {
-				inputVars.push(renderInputVar(name, schema, record));
-			}
-		}
-		for (const objectName of objectTypeNames) {
-			const record = schema.objects.get(objectName);
-			if (record) {
-				objectVars.push(renderObjectVar(name, schema, record));
-			}
-		}
-		for (const unionName of unionTypeNames) {
-			const record = schema.unions.get(unionName);
-			if (record) {
-				unionVars.push(renderUnionVar(name, record));
-			}
-		}
-		const allScalarNames = [...builtinScalarTypes.keys(), ...customScalarNames];
-		const factoryVar = `createMethod_${name}`;
-		const inputTypeMethodsBlock = renderInputTypeMethods(schema, factoryVar);
-		const directiveMethodsBlock = renderDirectiveMethods(schema);
-		const adapterTypeName = options?.injection?.get(name)?.adapterImportPath ? `Adapter_${name}` : undefined;
-		const fragmentBuildersTypeBlock = renderFragmentBuildersType(objectTypeNames, name, adapterTypeName);
-		const queryType = schema.operationTypes.query ?? "Query";
-		const mutationType = schema.operationTypes.mutation ?? "Mutation";
-		const subscriptionType = schema.operationTypes.subscription ?? "Subscription";
-		schemaConfigs[name] = {
-			queryType,
-			mutationType,
-			subscriptionType,
-			scalarVars,
-			enumVars,
-			inputVars,
-			objectVars,
-			unionVars,
-			scalarNames: allScalarNames,
-			enumNames: enumTypeNames,
-			inputNames: inputTypeNames,
-			objectNames: objectTypeNames,
-			unionNames: unionTypeNames,
-			inputTypeMethodsBlock,
-			directiveMethodsBlock,
-			fragmentBuildersTypeBlock,
-			defaultInputDepth: options?.defaultInputDepth?.get(name),
-			inputDepthOverrides: options?.inputDepthOverrides?.get(name)
-		};
-		allStats.objects += objectVars.length;
-		allStats.enums += enumVars.length;
-		allStats.inputs += inputVars.length;
-		allStats.unions += unionVars.length;
-	}
-	const injection = options?.injection ? {
-		mode: "inject",
-		perSchema: options.injection,
-		injectsModulePath: "./_internal-injects"
-	} : { mode: "inline" };
-	const splitting = { importPaths: {
-		enums: "./_defs/enums",
-		inputs: "./_defs/inputs",
-		objects: "./_defs/objects",
-		unions: "./_defs/unions"
-	} };
-	const code = multiRuntimeTemplate({
-		schemas: schemaConfigs,
-		injection,
-		splitting
-	});
-	const injectsCode = options?.injection ? generateInjectsCode(options.injection) : undefined;
-	const categoryVarsResult = Object.fromEntries(Object.entries(schemaConfigs).map(([schemaName, config]) => {
-		const toDefVar = (code$1, prefix) => {
-			const match = code$1.match(new RegExp(`const (${prefix}_${schemaName}_(\\w+))`));
-			return {
-				name: match?.[1] ?? "",
-				code: code$1
-			};
-		};
-		return [schemaName, {
-			enums: config.enumVars.map((c) => toDefVar(c, "enum")),
-			inputs: config.inputVars.map((c) => toDefVar(c, "input")),
-			objects: config.objectVars.map((c) => toDefVar(c, "object")),
-			unions: config.unionVars.map((c) => toDefVar(c, "union"))
-		}];
-	}));
-	return {
-		code,
-		injectsCode,
-		categoryVars: categoryVarsResult,
-		stats: allStats
-	};
-};
-
-//#endregion
-Object.defineProperty(exports, 'createSchemaIndex', {
-  enumerable: true,
-  get: function () {
-    return createSchemaIndex;
-  }
-});
-Object.defineProperty(exports, 'generateMultiSchemaModule', {
-  enumerable: true,
-  get: function () {
-    return generateMultiSchemaModule;
-  }
-});
-//# sourceMappingURL=generator-DvfP6gTY.cjs.map