@baeta/plugin-federation 0.0.0 → 2.0.0-next.13

package/dist/index.js

@@ -0,0 +1,1827 @@
+import fs from "node:fs/promises";
+import { createPluginV1, getModuleExportName } from "@baeta/generator-sdk";
+import { getSourcesFromSchema, loadSchema } from "@baeta/util-graphql";
+import { GraphQLList, GraphQLNonNull, Kind, isEnumType, isInterfaceType, isObjectType, isScalarType, parse, print, visit } from "graphql";
+import { relative } from "@baeta/util-path";
+import { mergeTypeDefs } from "@graphql-tools/merge";
+//#region lib/federation-info.ts
+function buildFederationInfo(spec, sources) {
+	const specDirectiveNames = new Set(spec.directives.map((d) => d.name));
+	const usedDirectiveNames = /* @__PURE__ */ new Set();
+	const resolvableInterfacesMap = /* @__PURE__ */ new Map();
+	const resolvableEntitiesMap = /* @__PURE__ */ new Map();
+	for (const source of sources) {
+		if (!source.document) continue;
+		visit(source.document, {
+			Directive(node) {
+				const directiveName = `@${node.name.value}`;
+				if (specDirectiveNames.has(directiveName)) usedDirectiveNames.add(directiveName);
+			},
+			InterfaceTypeDefinition(node) {
+				addKeyDirectivesSelectionSetToMap(resolvableInterfacesMap, node.name.value, node.directives);
+			},
+			InterfaceTypeExtension(node) {
+				addKeyDirectivesSelectionSetToMap(resolvableInterfacesMap, node.name.value, node.directives);
+			}
+		});
+	}
+	for (const source of sources) {
+		if (!source.document) continue;
+		visit(source.document, {
+			ObjectTypeDefinition(node) {
+				addKeyDirectivesSelectionSetToMap(resolvableEntitiesMap, node.name.value, node.directives);
+				inheritInterfaceSelectionSets(resolvableInterfacesMap, resolvableEntitiesMap, node.name.value, node.interfaces);
+			},
+			ObjectTypeExtension(node) {
+				addKeyDirectivesSelectionSetToMap(resolvableEntitiesMap, node.name.value, node.directives);
+				inheritInterfaceSelectionSets(resolvableInterfacesMap, resolvableEntitiesMap, node.name.value, node.interfaces);
+			}
+		});
+	}
+	return {
+		usedDirectiveNames,
+		resolvableEntitiesMap
+	};
+}
+function inheritInterfaceSelectionSets(interfacesSelectionsMap, map, entityName, entityInterfaces = []) {
+	for (const iface of entityInterfaces) {
+		const ifaceName = iface.name.value;
+		const ifaceSelections = interfacesSelectionsMap.get(ifaceName);
+		if (!ifaceSelections) continue;
+		const existing = map.get(entityName) ?? /* @__PURE__ */ new Set();
+		for (const selectionSet of ifaceSelections) existing.add(selectionSet);
+		map.set(entityName, existing);
+	}
+}
+function addKeyDirectivesSelectionSetToMap(map, typeName, directives = []) {
+	for (const directive of directives) {
+		const selectionSet = getKeyDirectiveSelectionSet(directive);
+		if (!selectionSet) continue;
+		const existing = map.get(typeName) ?? /* @__PURE__ */ new Set();
+		existing.add(selectionSet);
+		map.set(typeName, existing);
+	}
+}
+function getKeyDirectiveSelectionSet(directive) {
+	if (directive.name.value !== "key") return null;
+	const fieldsArg = directive.arguments?.find((arg) => arg.name.value === "fields");
+	if (!fieldsArg) return null;
+	if (fieldsArg.value.kind !== Kind.STRING) return null;
+	const resolvableArg = directive.arguments?.find((arg) => arg.name.value === "resolvable");
+	if (resolvableArg && resolvableArg.value.kind === Kind.BOOLEAN && resolvableArg.value.value === false) return null;
+	return fieldsArg.value.value.trim().replaceAll(/\s+/g, "");
+}
+//#endregion
+//#region lib/print-federation-types.ts
+function printFederationTypes(schema, federationInfo, options) {
+	const entitiesRepresentations = [...federationInfo.resolvableEntitiesMap.entries()].map(([typeName, fields]) => buildRepresentationForType(schema, typeName, fields));
+	const entityHandlerTypes = [...federationInfo.resolvableEntitiesMap.keys()].map((typeName) => buildEntityHandlerTypeForType(typeName));
+	const entityRepresentationUnion = [...federationInfo.resolvableEntitiesMap.keys()].map((typeName) => `${typeName}EntityRepresentation`).join(" | ") || "never";
+	return [
+		`import type {Ctx, Info} from "${relative(options.typesDir, options.modulesDir)}/types${options.extension}";`,
+		`import * as Types from "./types${options.extension}";`,
+		"",
+		"type Result<T> = T | PromiseLike<T>;",
+		"",
+		entitiesRepresentations.join("\n\n"),
+		"",
+		entityHandlerTypes.join("\n\n"),
+		"",
+		`export type EntityRepresentation = ${entityRepresentationUnion};`,
+		"",
+		`export type EntityHandlerMap = { ${[...federationInfo.resolvableEntitiesMap.keys()].map((typeName) => `"${typeName}": ${typeName}EntityHandler`).join("; ")} };`
+	].join("\n");
+}
+function buildEntityHandlerTypeForType(typeName) {
+	return `export type ${typeName}EntityHandler = (representation: ${typeName}EntityRepresentation, ctx: Ctx, info: Info) => Result<Types.${typeName} & {__typename: "${typeName}"} | null>`;
+}
+function buildRepresentationForType(schema, typeName, fields) {
+	const objectType = schema.getType(typeName);
+	if (!objectType || !isObjectType(objectType)) throw new Error(`Type "${typeName}" not found or is not an object type`);
+	return `export type ${typeName}EntityRepresentation = { __typename: "${typeName}" } & (${[...fields].map((fieldSet) => buildShape(objectType, fieldSet)).join(" | ")})`;
+}
+function buildShape(type, keyFields) {
+	const doc = parse(`{ ${keyFields} }`);
+	const selectionSet = doc.definitions[0].kind === Kind.OPERATION_DEFINITION ? doc.definitions[0].selectionSet : null;
+	if (!selectionSet) throw new Error("Invalid key fields");
+	return selectionSetToTS(selectionSet, type);
+}
+function selectionSetToTS(selectionSet, parentType) {
+	const fields = parentType.getFields();
+	const parts = [];
+	for (const selection of selectionSet.selections) {
+		if (selection.kind !== Kind.FIELD) continue;
+		const name = selection.name.value;
+		const field = fields[name];
+		if (!field) throw new Error(`Field "${name}" not found on ${parentType.name}`);
+		const naked = unwrap(field.type);
+		if (isScalarType(naked) || isEnumType(naked)) parts.push(`${name}: ${scalarToTS(naked.name)}`);
+		else if ((isObjectType(naked) || isInterfaceType(naked)) && selection.selectionSet) {
+			const nested = selectionSetToTS(selection.selectionSet, naked);
+			parts.push(`${name}: ${nested}`);
+		}
+	}
+	return `{ ${parts.join("; ")} }`;
+}
+function unwrap(type) {
+	if (type instanceof GraphQLNonNull || type instanceof GraphQLList) return unwrap(type.ofType);
+	return type;
+}
+function scalarToTS(name) {
+	return `Types.Scalars["${name}"]`;
+}
+//#endregion
+//#region lib/print-handlers-starter.ts
+function printHandlersStarter(options) {
+	return [
+		"/**",
+		"* Register your reference resolvers for federation entities in this file.",
+		"* This file is generated by Baeta, but it will not be overwritten once created,",
+		"* so it's safe to edit it directly.",
+		"*/",
+		"",
+		`import type { EntityHandlerMap } from "${relative(options.federationRootDir, options.typesDir)}/federation.ts";`,
+		"",
+		"const entityHandlersMap: EntityHandlerMap = {",
+		"",
+		"};",
+		"",
+		"export default entityHandlersMap;"
+	].join("\n");
+}
+//#endregion
+//#region lib/print-resolvers.ts
+function printResolvers(spec, info, options) {
+	const moduleExportName = getModuleExportName(options.moduleName);
+	const imports = [
+		"import * as BaetaFederation from \"@baeta/federation\"",
+		`import type * as FederationTypes from "${relative(options.federationRootDir, options.typesDir)}/federation${options.extension}"`,
+		`import federationSDL from "./federation-sdl${options.extension}"`,
+		`import { ${moduleExportName} } from "./${options.moduleDefinitionName}${options.extension}"`,
+		info.resolvableEntitiesMap.size > 0 ? `import handlersMap from "./entity-handlers${options.extension}"` : null
+	].filter((el) => el != null).join(";\n");
+	const scalarResolvers = getUniqueScalars(spec, options.includedDirectiveNames).map(printScalarResolver);
+	const moduleExportBody = [
+		printQueryTypeResolver(info, moduleExportName),
+		printServiceTypeResolver(moduleExportName),
+		printScalarResolver({
+			name: "_Any",
+			serialize: "json"
+		}),
+		...scalarResolvers
+	].map(ident(2)).join(",\n");
+	return [
+		imports,
+		"",
+		[
+			`export default ${moduleExportName}.$schema({`,
+			moduleExportBody,
+			"});"
+		].join("\n")
+	].join("\n");
+}
+function printScalarResolver(scalar) {
+	return `${scalar.name}: BaetaFederation.createFederationScalar('${scalar.serialize}', '${scalar.name}')`;
+}
+function printServiceTypeResolver(moduleExportName) {
+	return [
+		`_Service: ${moduleExportName}._Service.$fields({`,
+		`  sdl: ${moduleExportName}._Service.sdl.key('sdl'),`,
+		"})"
+	].join("\n");
+}
+function printQueryTypeResolver(info, moduleExportName) {
+	return [
+		`Query: ${moduleExportName}.Query.$fields({`,
+		info.resolvableEntitiesMap.size > 0 ? printEntityFieldResolver(moduleExportName) : null,
+		`  _service: ${moduleExportName}.Query._service.resolve(() => {`,
+		"    return { sdl: federationSDL };",
+		"  }),",
+		"})"
+	].filter((el) => el != null).join("\n");
+}
+function printEntityFieldResolver(moduleExportName) {
+	return [
+		`_entities: ${moduleExportName}.Query._entities.resolve((params) => {`,
+		"  const representations = params.args.representations as FederationTypes.EntityRepresentation[];",
+		"  return BaetaFederation.resolveEntities(representations, handlersMap satisfies FederationTypes.EntityHandlerMap, params.ctx, params.info);",
+		"}),"
+	].map(ident(2)).join("\n");
+}
+function getUniqueScalars(spec, included) {
+	const seen = /* @__PURE__ */ new Set();
+	const scalars = [];
+	for (const directive of spec.directives) {
+		if (!included.has(directive.name)) continue;
+		if (!directive.scalars) continue;
+		for (const scalar of directive.scalars) {
+			if (seen.has(scalar.name)) continue;
+			seen.add(scalar.name);
+			scalars.push(scalar);
+		}
+	}
+	return scalars;
+}
+function ident(spaces) {
+	return (str) => {
+		const padding = " ".repeat(spaces);
+		return str.split("\n").map((line) => padding + line).join("\n");
+	};
+}
+//#endregion
+//#region lib/print-schema-spec.ts
+function printSchemaSpec(spec, include) {
+	const directives = spec.directives.filter((d) => include.has(d.name));
+	const scalars = pickUniqueScalars(directives);
+	return [
+		`# Federation Specification ${spec.version}`,
+		"",
+		...directives.map(printDirective),
+		"",
+		...scalars.map(printScalar),
+		scalars.length > 0 ? "" : null
+	].filter((el) => el != null).join("\n");
+}
+function printDirective(directive) {
+	return [
+		`directive ${directive.name}${printArgs(directive.args)}`,
+		directive.locations.length > 0 && directive.repeatable ? "repeatable" : null,
+		directive.locations.length > 0 ? `on ${directive.locations.join(" | ")}` : null
+	].filter((el) => el != null).join(" ");
+}
+function printArgs(args) {
+	if (!args || args.length === 0) return "";
+	return `(${args.map(printArg).join(", ")})`;
+}
+function printArg(arg) {
+	return `${arg.name}: ${arg.type}${printArgDefaultValue(arg.defaultValue)}`;
+}
+function printArgDefaultValue(value) {
+	if (value === void 0) return "";
+	if (typeof value === "string") return ` = ${JSON.stringify(value)}`;
+	return ` = ${value}`;
+}
+function printScalar(scalar) {
+	return `scalar ${scalar.name}`;
+}
+function pickUniqueScalars(directives) {
+	const seen = /* @__PURE__ */ new Set();
+	const uniqueScalars = [];
+	for (const directive of directives) for (const scalar of directive.scalars ?? []) if (!seen.has(scalar.name)) {
+		seen.add(scalar.name);
+		uniqueScalars.push(scalar);
+	}
+	return uniqueScalars;
+}
+//#endregion
+//#region lib/print-schema-types.ts
+function printSchemaTypes(federationInfo) {
+	const entities = [...federationInfo.resolvableEntitiesMap.keys()];
+	const queryType = [
+		"type Query {",
+		"  _service: _Service!",
+		entities.length > 0 ? "  _entities(representations: [_Any!]!): [_Entity]!" : null,
+		"}"
+	].filter((el) => el != null).join("\n");
+	return [
+		"scalar _Any",
+		entities.length > 0 ? `union _Entity = ${entities.join(" | ")}` : "",
+		"type _Service { sdl: String! }",
+		queryType
+	].filter((s) => s).join("\n\n");
+}
+//#endregion
+//#region lib/print-sdl.ts
+function printSDL(spec, sources, federationInfo) {
+	const importList = [...federationInfo.usedDirectiveNames].map((name) => `"${name}"`).join(", ");
+	const repeatableDirectives = new Set(spec.directives.filter((d) => d.repeatable).map((d) => d.name.replace("@", "")));
+	return `export default \`${[
+		"",
+		print(mergeTypeDefs([parse(`extend schema @link(url: "https://specs.apollo.dev/federation/v${spec.version}", import: [${importList}])`), ...sources.map((s) => s.document).filter((el) => el != null)], {
+			useSchemaDefinition: false,
+			repeatableLinkImports: repeatableDirectives
+		})),
+		""
+	].join("\n")}\`;`;
+}
+const federationSpecs = [
+	{
+		version: "2.0",
+		directives: [
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"]
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.1",
+		directives: [
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"]
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.2",
+		directives: [
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.3",
+		directives: [
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.4",
+		directives: [
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.5",
+		directives: [
+			{
+				name: "@authenticated",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				]
+			},
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requiresScopes",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "scopes",
+					type: "[[Scope!]!]!"
+				}],
+				scalars: [{
+					name: "Scope",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.6",
+		directives: [
+			{
+				name: "@authenticated",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				]
+			},
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@policy",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "policies",
+					type: "[[Policy!]!]!"
+				}],
+				scalars: [{
+					name: "Policy",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requiresScopes",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "scopes",
+					type: "[[Scope!]!]!"
+				}],
+				scalars: [{
+					name: "Scope",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.7",
+		directives: [
+			{
+				name: "@authenticated",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				]
+			},
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}, {
+					name: "label",
+					type: "String"
+				}]
+			},
+			{
+				name: "@policy",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "policies",
+					type: "[[Policy!]!]!"
+				}],
+				scalars: [{
+					name: "Policy",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requiresScopes",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "scopes",
+					type: "[[Scope!]!]!"
+				}],
+				scalars: [{
+					name: "Scope",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.8",
+		directives: [
+			{
+				name: "@authenticated",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				]
+			},
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@context",
+				locations: [
+					"OBJECT",
+					"INTERFACE",
+					"UNION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@fromContext",
+				locations: ["ARGUMENT_DEFINITION"],
+				args: [{
+					name: "field",
+					type: "ContextFieldValue"
+				}],
+				scalars: [{
+					name: "ContextFieldValue",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}, {
+					name: "label",
+					type: "String"
+				}]
+			},
+			{
+				name: "@policy",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "policies",
+					type: "[[Policy!]!]!"
+				}],
+				scalars: [{
+					name: "Policy",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requiresScopes",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "scopes",
+					type: "[[Scope!]!]!"
+				}],
+				scalars: [{
+					name: "Scope",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	},
+	{
+		version: "2.9",
+		directives: [
+			{
+				name: "@authenticated",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				]
+			},
+			{
+				name: "@composeDirective",
+				locations: ["SCHEMA"],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			},
+			{
+				name: "@context",
+				locations: [
+					"OBJECT",
+					"INTERFACE",
+					"UNION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}]
+			},
+			{
+				name: "@cost",
+				locations: [
+					"ARGUMENT_DEFINITION",
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INPUT_FIELD_DEFINITION",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "weight",
+					type: "Int!"
+				}]
+			},
+			{
+				name: "@extends",
+				locations: ["OBJECT", "INTERFACE"]
+			},
+			{
+				name: "@external",
+				locations: ["OBJECT", "FIELD_DEFINITION"]
+			},
+			{
+				name: "@fromContext",
+				locations: ["ARGUMENT_DEFINITION"],
+				args: [{
+					name: "field",
+					type: "ContextFieldValue"
+				}],
+				scalars: [{
+					name: "ContextFieldValue",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@key",
+				locations: ["OBJECT", "INTERFACE"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}, {
+					name: "resolvable",
+					type: "Boolean",
+					defaultValue: true
+				}],
+				repeatable: true,
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@inaccessible",
+				locations: [
+					"FIELD_DEFINITION",
+					"OBJECT",
+					"INTERFACE",
+					"UNION",
+					"ENUM",
+					"ENUM_VALUE",
+					"SCALAR",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION",
+					"ARGUMENT_DEFINITION"
+				]
+			},
+			{
+				name: "@interfaceObject",
+				locations: ["OBJECT"]
+			},
+			{
+				name: "@listSize",
+				locations: ["FIELD_DEFINITION"],
+				args: [
+					{
+						name: "assumedSize",
+						type: "Int"
+					},
+					{
+						name: "slicingArguments",
+						type: "[String!]"
+					},
+					{
+						name: "sizedFields",
+						type: "[String!]"
+					},
+					{
+						name: "requireOneSlicingArgument",
+						type: "Boolean",
+						defaultValue: true
+					}
+				]
+			},
+			{
+				name: "@override",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "from",
+					type: "String!"
+				}, {
+					name: "label",
+					type: "String"
+				}]
+			},
+			{
+				name: "@policy",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "policies",
+					type: "[[Policy!]!]!"
+				}],
+				scalars: [{
+					name: "Policy",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@provides",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requires",
+				locations: ["FIELD_DEFINITION"],
+				args: [{
+					name: "fields",
+					type: "FieldSet!"
+				}],
+				scalars: [{
+					name: "FieldSet",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@requiresScopes",
+				locations: [
+					"ENUM",
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"SCALAR"
+				],
+				args: [{
+					name: "scopes",
+					type: "[[Scope!]!]!"
+				}],
+				scalars: [{
+					name: "Scope",
+					serialize: "string"
+				}]
+			},
+			{
+				name: "@shareable",
+				locations: ["FIELD_DEFINITION", "OBJECT"],
+				repeatable: true
+			},
+			{
+				name: "@tag",
+				locations: [
+					"FIELD_DEFINITION",
+					"INTERFACE",
+					"OBJECT",
+					"UNION",
+					"ARGUMENT_DEFINITION",
+					"SCALAR",
+					"ENUM",
+					"ENUM_VALUE",
+					"INPUT_OBJECT",
+					"INPUT_FIELD_DEFINITION"
+				],
+				args: [{
+					name: "name",
+					type: "String!"
+				}],
+				repeatable: true
+			}
+		]
+	}
+];
+//#endregion
+//#region lib/specs.ts
+function findSpecification(version) {
+	const spec = federationSpecs.find((s) => s.version === version);
+	if (!spec) throw new Error(`Unsupported federation version: ${version}`);
+	return spec;
+}
+//#endregion
+//#region index.ts
+const DEFAULT_MODULE_NAME = "baeta-federation";
+const DEFAULT_VERSION = "2.9";
+const DEFAULT_DIRECTIVES = [
+	"@key",
+	"@external",
+	"@requires",
+	"@provides",
+	"@extends"
+];
+function federationPlugin(options) {
+	return createPluginV1({
+		name: "graphql",
+		actionName: "GraphQL federation",
+		watch: (generatorOptions, watcher) => {
+			const federationRootDir = getModuleRootDir(generatorOptions.modulesDir, options);
+			watcher.ignore(`${federationRootDir}/*.gql`);
+		},
+		generate: async (ctx, next) => {
+			const moduleName = options?.moduleName ?? DEFAULT_MODULE_NAME;
+			const specification = findSpecification(options?.version ?? DEFAULT_VERSION);
+			const directiveNames = buildDirectiveNames(specification, options?.include);
+			const federationRootDir = getModuleRootDir(ctx.generatorOptions.modulesDir, options);
+			const federationTypesFilePath = `${ctx.generatorOptions.typesDir}/federation.ts`;
+			const sdlFilePath = `${federationRootDir}/federation-sdl.ts`;
+			const schemaSpecFilePath = `${federationRootDir}/federation-spec.gql`;
+			const schemaTypesFilePath = `${federationRootDir}/federation-types.gql`;
+			const entityHandlersFilePath = `${federationRootDir}/entity-handlers.ts`;
+			const resolversFilePath = `${federationRootDir}/index.ts`;
+			const schemaSpecFile = ctx.fileManager.createAndAdd(schemaSpecFilePath, printSchemaSpec(specification, directiveNames), "federation");
+			await Promise.all([await schemaSpecFile.write(), fs.unlink(schemaTypesFilePath).catch(() => {})]);
+			const { outputSchemaAst } = await loadSchema(ctx.generatorOptions.schemas, ctx.generatorOptions.cwd, ctx.generatorOptions.loaders);
+			const sources = getSourcesFromSchema(outputSchemaAst).filter((source) => {
+				return source.location !== schemaSpecFilePath && source.location !== schemaTypesFilePath;
+			});
+			const federationInfo = buildFederationInfo(specification, sources);
+			ctx.fileManager.createAndAdd(sdlFilePath, printSDL(specification, sources, federationInfo), "federation");
+			ctx.fileManager.createAndAdd(federationTypesFilePath, printFederationTypes(outputSchemaAst, federationInfo, {
+				extension: ctx.generatorOptions.importExtension,
+				modulesDir: ctx.generatorOptions.modulesDir,
+				typesDir: ctx.generatorOptions.typesDir
+			}), "federation");
+			ctx.fileManager.createAndAdd(resolversFilePath, printResolvers(specification, federationInfo, {
+				moduleName,
+				typesDir: ctx.generatorOptions.typesDir,
+				federationRootDir,
+				extension: ctx.generatorOptions.importExtension,
+				moduleDefinitionName: ctx.generatorOptions.moduleDefinitionName,
+				includedDirectiveNames: directiveNames
+			}), "federation");
+			ctx.fileManager.createAndAdd(entityHandlersFilePath, printHandlersStarter({
+				typesDir: ctx.generatorOptions.typesDir,
+				federationRootDir,
+				extension: ctx.generatorOptions.importExtension
+			}), "federation", {
+				disableOverwrite: true,
+				disableBiomeV1Header: true,
+				disableBiomeV2Header: true,
+				disableEslintHeader: true,
+				disableGenerationNoticeHeader: true
+			});
+			await ctx.fileManager.createAndAdd(schemaTypesFilePath, printSchemaTypes(federationInfo), "federation").write();
+			return next();
+		}
+	});
+}
+function getModuleRootDir(modulesDir, options) {
+	return `${modulesDir}/${options?.moduleName ?? DEFAULT_MODULE_NAME}`;
+}
+function buildDirectiveNames(spec, include = []) {
+	if (include === "all") return new Set(spec.directives.map((d) => d.name));
+	return new Set([...DEFAULT_DIRECTIVES, ...include]);
+}
+//#endregion
+export { federationPlugin };
+
+//# sourceMappingURL=index.js.map