@graphql-mesh/transform-federation 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/cjs/index.js

@@ -0,0 +1,231 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const dset_1 = require("dset");
+const graphql_1 = require("graphql");
+const types_js_1 = require("@apollo/subgraph/dist/types.js");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
+const federationDirectives = [
+    'link',
+    'key',
+    'interfaceObject',
+    'extends',
+    'shareable',
+    'inaccessible',
+    'override',
+    'external',
+    'provides',
+    'requires',
+    'tag',
+    'composeDirective',
+];
+class FederationTransform {
+    constructor({ apiName, baseDir, config, importFn, }) {
+        this.noWrap = true;
+        this.apiName = apiName;
+        this.config = config;
+        this.baseDir = baseDir;
+        this.importFn = importFn;
+    }
+    transformSchema(schema, rawSource) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        rawSource.merge = {};
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.types) {
+            const queryType = schema.getQueryType();
+            const queryTypeFields = queryType.getFields();
+            for (const type of this.config.types) {
+                rawSource.merge[type.name] = {};
+                const typeObj = schema.getType(type.name);
+                typeObj.extensions = typeObj.extensions || {};
+                const typeDirectivesObj = (typeObj.extensions.directives =
+                    typeObj.extensions.directives || {});
+                if ((_b = type.config) === null || _b === void 0 ? void 0 : _b.key) {
+                    typeDirectivesObj.key = type.config.key;
+                }
+                if ((_c = type.config) === null || _c === void 0 ? void 0 : _c.shareable) {
+                    typeDirectivesObj.shareable = type.config.shareable;
+                }
+                if ((_d = type.config) === null || _d === void 0 ? void 0 : _d.extends) {
+                    typeDirectivesObj.extends = type.config.extends;
+                }
+                const typeFieldObjs = typeObj.getFields();
+                if ((_e = type.config) === null || _e === void 0 ? void 0 : _e.fields) {
+                    for (const field of type.config.fields) {
+                        const typeField = typeFieldObjs[field.name];
+                        if (typeField) {
+                            typeField.extensions = typeField.extensions || {};
+                            const directivesObj = (typeField.extensions.directives =
+                                typeField.extensions.directives || {});
+                            Object.assign(directivesObj, field.config);
+                        }
+                        rawSource.merge[type.name].fields = rawSource.merge[type.name].fields || {};
+                        rawSource.merge[type.name].fields[field.name] =
+                            rawSource.merge[type.name].fields[field.name] || {};
+                        if (field.config.requires) {
+                            rawSource.merge[type.name].fields[field.name].computed = true;
+                            rawSource.merge[type.name].fields[field.name].selectionSet = `{ ${field.config.requires} }`;
+                        }
+                    }
+                }
+                // If a field is a key field, it should be GraphQLID
+                if ((_f = type.config) === null || _f === void 0 ? void 0 : _f.key) {
+                    let selectionSetContent = '';
+                    for (const keyField of type.config.key) {
+                        selectionSetContent += '\n';
+                        selectionSetContent += keyField.fields || '';
+                    }
+                    if (selectionSetContent) {
+                        rawSource.merge[type.name].selectionSet = `{ ${selectionSetContent} }`;
+                    }
+                }
+                let resolveReference;
+                if ((_g = type.config) === null || _g === void 0 ? void 0 : _g.resolveReference) {
+                    const resolveReferenceConfig = type.config.resolveReference;
+                    if (typeof resolveReferenceConfig === 'string') {
+                        const fn$ = (0, utils_1.loadFromModuleExportExpression)(resolveReferenceConfig, {
+                            cwd: this.baseDir,
+                            defaultExportName: 'default',
+                            importFn: this.importFn,
+                        });
+                        resolveReference = (...args) => fn$.then(fn => fn(...args));
+                    }
+                    else if (typeof resolveReferenceConfig === 'function') {
+                        resolveReference = resolveReferenceConfig;
+                    }
+                    else {
+                        const queryField = queryTypeFields[resolveReferenceConfig.queryFieldName];
+                        resolveReference = async (root, context, info) => {
+                            const args = {};
+                            for (const argName in resolveReferenceConfig.args) {
+                                const argVal = string_interpolation_1.stringInterpolator.parse(resolveReferenceConfig.args[argName], {
+                                    root,
+                                    args,
+                                    context,
+                                    info,
+                                    env: process.env,
+                                });
+                                if (argVal) {
+                                    (0, dset_1.dset)(args, argName, argVal);
+                                }
+                            }
+                            const result = await context[this.apiName].Query[queryField.name]({
+                                root,
+                                args,
+                                context,
+                                info,
+                            });
+                            return {
+                                ...root,
+                                ...result,
+                            };
+                        };
+                    }
+                    rawSource.merge[type.name].resolve = resolveReference;
+                }
+            }
+        }
+        const entityTypes = [];
+        for (const typeName in rawSource.merge || {}) {
+            const type = schema.getType(typeName);
+            if ((0, graphql_1.isObjectType)(type)) {
+                entityTypes.push(type);
+            }
+            (0, dset_1.dset)(type, 'extensions.apollo.subgraph.resolveReference', rawSource.merge[typeName].resolve);
+        }
+        const schemaWithFederationQueryType = (0, utils_2.mapSchema)(schema, {
+            [utils_2.MapperKind.QUERY]: type => {
+                const config = type.toConfig();
+                return new graphql_1.GraphQLObjectType({
+                    ...config,
+                    fields: {
+                        ...config.fields,
+                        _entities: types_js_1.entitiesField,
+                        _service: {
+                            ...types_js_1.serviceField,
+                            resolve: (root, args, context, info) => ({
+                                sdl: (0, utils_2.printSchemaWithDirectives)(info.schema),
+                            }),
+                        },
+                    },
+                });
+            },
+        });
+        const schemaWithUnionType = (0, utils_2.mapSchema)(schemaWithFederationQueryType, {
+            [utils_2.MapperKind.UNION_TYPE]: type => {
+                if (type.name === types_js_1.EntityType.name) {
+                    return new graphql_1.GraphQLUnionType({
+                        ...types_js_1.EntityType.toConfig(),
+                        types: entityTypes,
+                    });
+                }
+                return type;
+            },
+        });
+        schemaWithUnionType.extensions = schemaWithUnionType.extensions || {};
+        const directivesObj = (schemaWithUnionType.extensions.directives =
+            schemaWithUnionType.extensions.directives || {});
+        const existingDirectives = schemaWithUnionType.getDirectives();
+        const filteredDirectives = existingDirectives.filter(directive => federationDirectives.includes(directive.name));
+        directivesObj.link = {
+            url: 'https://specs.apollo.dev/federation/' + (this.config.version || 'v2.0'),
+            import: filteredDirectives
+                .filter(({ name }) => name !== 'link')
+                .map(dirName => `@${dirName.name}`),
+        };
+        if (existingDirectives.length === filteredDirectives.length) {
+            return schemaWithUnionType;
+        }
+        return (0, utils_2.mapSchema)(schemaWithUnionType, {
+            [utils_2.MapperKind.DIRECTIVE]: directive => {
+                if (federationDirectives.includes(directive.name)) {
+                    return directive;
+                }
+                return null;
+            },
+            [utils_2.MapperKind.OBJECT_TYPE]: type => {
+                var _a, _b;
+                return new graphql_1.GraphQLObjectType({
+                    ...type.toConfig(),
+                    astNode: type.astNode && {
+                        ...type.astNode,
+                        directives: (_a = type.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...type.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = type.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                });
+            },
+            [utils_2.MapperKind.INTERFACE_TYPE]: type => {
+                var _a, _b;
+                return new graphql_1.GraphQLInterfaceType({
+                    ...type.toConfig(),
+                    astNode: type.astNode && {
+                        ...type.astNode,
+                        directives: (_a = type.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...type.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = type.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                });
+            },
+            [utils_2.MapperKind.COMPOSITE_FIELD]: fieldConfig => {
+                var _a, _b;
+                return {
+                    ...fieldConfig,
+                    astNode: fieldConfig.astNode && {
+                        ...fieldConfig.astNode,
+                        directives: (_a = fieldConfig.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...fieldConfig.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = fieldConfig.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                };
+            },
+        });
+    }
+}
+exports.default = FederationTransform;

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/index.js

@@ -0,0 +1,228 @@
+import { dset } from 'dset';
+import { GraphQLInterfaceType, GraphQLObjectType, GraphQLUnionType, isObjectType, } from 'graphql';
+import { entitiesField, EntityType, serviceField } from '@apollo/subgraph/dist/types.js';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { loadFromModuleExportExpression } from '@graphql-mesh/utils';
+import { MapperKind, mapSchema, printSchemaWithDirectives } from '@graphql-tools/utils';
+const federationDirectives = [
+    'link',
+    'key',
+    'interfaceObject',
+    'extends',
+    'shareable',
+    'inaccessible',
+    'override',
+    'external',
+    'provides',
+    'requires',
+    'tag',
+    'composeDirective',
+];
+export default class FederationTransform {
+    constructor({ apiName, baseDir, config, importFn, }) {
+        this.noWrap = true;
+        this.apiName = apiName;
+        this.config = config;
+        this.baseDir = baseDir;
+        this.importFn = importFn;
+    }
+    transformSchema(schema, rawSource) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        rawSource.merge = {};
+        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.types) {
+            const queryType = schema.getQueryType();
+            const queryTypeFields = queryType.getFields();
+            for (const type of this.config.types) {
+                rawSource.merge[type.name] = {};
+                const typeObj = schema.getType(type.name);
+                typeObj.extensions = typeObj.extensions || {};
+                const typeDirectivesObj = (typeObj.extensions.directives =
+                    typeObj.extensions.directives || {});
+                if ((_b = type.config) === null || _b === void 0 ? void 0 : _b.key) {
+                    typeDirectivesObj.key = type.config.key;
+                }
+                if ((_c = type.config) === null || _c === void 0 ? void 0 : _c.shareable) {
+                    typeDirectivesObj.shareable = type.config.shareable;
+                }
+                if ((_d = type.config) === null || _d === void 0 ? void 0 : _d.extends) {
+                    typeDirectivesObj.extends = type.config.extends;
+                }
+                const typeFieldObjs = typeObj.getFields();
+                if ((_e = type.config) === null || _e === void 0 ? void 0 : _e.fields) {
+                    for (const field of type.config.fields) {
+                        const typeField = typeFieldObjs[field.name];
+                        if (typeField) {
+                            typeField.extensions = typeField.extensions || {};
+                            const directivesObj = (typeField.extensions.directives =
+                                typeField.extensions.directives || {});
+                            Object.assign(directivesObj, field.config);
+                        }
+                        rawSource.merge[type.name].fields = rawSource.merge[type.name].fields || {};
+                        rawSource.merge[type.name].fields[field.name] =
+                            rawSource.merge[type.name].fields[field.name] || {};
+                        if (field.config.requires) {
+                            rawSource.merge[type.name].fields[field.name].computed = true;
+                            rawSource.merge[type.name].fields[field.name].selectionSet = `{ ${field.config.requires} }`;
+                        }
+                    }
+                }
+                // If a field is a key field, it should be GraphQLID
+                if ((_f = type.config) === null || _f === void 0 ? void 0 : _f.key) {
+                    let selectionSetContent = '';
+                    for (const keyField of type.config.key) {
+                        selectionSetContent += '\n';
+                        selectionSetContent += keyField.fields || '';
+                    }
+                    if (selectionSetContent) {
+                        rawSource.merge[type.name].selectionSet = `{ ${selectionSetContent} }`;
+                    }
+                }
+                let resolveReference;
+                if ((_g = type.config) === null || _g === void 0 ? void 0 : _g.resolveReference) {
+                    const resolveReferenceConfig = type.config.resolveReference;
+                    if (typeof resolveReferenceConfig === 'string') {
+                        const fn$ = loadFromModuleExportExpression(resolveReferenceConfig, {
+                            cwd: this.baseDir,
+                            defaultExportName: 'default',
+                            importFn: this.importFn,
+                        });
+                        resolveReference = (...args) => fn$.then(fn => fn(...args));
+                    }
+                    else if (typeof resolveReferenceConfig === 'function') {
+                        resolveReference = resolveReferenceConfig;
+                    }
+                    else {
+                        const queryField = queryTypeFields[resolveReferenceConfig.queryFieldName];
+                        resolveReference = async (root, context, info) => {
+                            const args = {};
+                            for (const argName in resolveReferenceConfig.args) {
+                                const argVal = stringInterpolator.parse(resolveReferenceConfig.args[argName], {
+                                    root,
+                                    args,
+                                    context,
+                                    info,
+                                    env: process.env,
+                                });
+                                if (argVal) {
+                                    dset(args, argName, argVal);
+                                }
+                            }
+                            const result = await context[this.apiName].Query[queryField.name]({
+                                root,
+                                args,
+                                context,
+                                info,
+                            });
+                            return {
+                                ...root,
+                                ...result,
+                            };
+                        };
+                    }
+                    rawSource.merge[type.name].resolve = resolveReference;
+                }
+            }
+        }
+        const entityTypes = [];
+        for (const typeName in rawSource.merge || {}) {
+            const type = schema.getType(typeName);
+            if (isObjectType(type)) {
+                entityTypes.push(type);
+            }
+            dset(type, 'extensions.apollo.subgraph.resolveReference', rawSource.merge[typeName].resolve);
+        }
+        const schemaWithFederationQueryType = mapSchema(schema, {
+            [MapperKind.QUERY]: type => {
+                const config = type.toConfig();
+                return new GraphQLObjectType({
+                    ...config,
+                    fields: {
+                        ...config.fields,
+                        _entities: entitiesField,
+                        _service: {
+                            ...serviceField,
+                            resolve: (root, args, context, info) => ({
+                                sdl: printSchemaWithDirectives(info.schema),
+                            }),
+                        },
+                    },
+                });
+            },
+        });
+        const schemaWithUnionType = mapSchema(schemaWithFederationQueryType, {
+            [MapperKind.UNION_TYPE]: type => {
+                if (type.name === EntityType.name) {
+                    return new GraphQLUnionType({
+                        ...EntityType.toConfig(),
+                        types: entityTypes,
+                    });
+                }
+                return type;
+            },
+        });
+        schemaWithUnionType.extensions = schemaWithUnionType.extensions || {};
+        const directivesObj = (schemaWithUnionType.extensions.directives =
+            schemaWithUnionType.extensions.directives || {});
+        const existingDirectives = schemaWithUnionType.getDirectives();
+        const filteredDirectives = existingDirectives.filter(directive => federationDirectives.includes(directive.name));
+        directivesObj.link = {
+            url: 'https://specs.apollo.dev/federation/' + (this.config.version || 'v2.0'),
+            import: filteredDirectives
+                .filter(({ name }) => name !== 'link')
+                .map(dirName => `@${dirName.name}`),
+        };
+        if (existingDirectives.length === filteredDirectives.length) {
+            return schemaWithUnionType;
+        }
+        return mapSchema(schemaWithUnionType, {
+            [MapperKind.DIRECTIVE]: directive => {
+                if (federationDirectives.includes(directive.name)) {
+                    return directive;
+                }
+                return null;
+            },
+            [MapperKind.OBJECT_TYPE]: type => {
+                var _a, _b;
+                return new GraphQLObjectType({
+                    ...type.toConfig(),
+                    astNode: type.astNode && {
+                        ...type.astNode,
+                        directives: (_a = type.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...type.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = type.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                });
+            },
+            [MapperKind.INTERFACE_TYPE]: type => {
+                var _a, _b;
+                return new GraphQLInterfaceType({
+                    ...type.toConfig(),
+                    astNode: type.astNode && {
+                        ...type.astNode,
+                        directives: (_a = type.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...type.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = type.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                });
+            },
+            [MapperKind.COMPOSITE_FIELD]: fieldConfig => {
+                var _a, _b;
+                return {
+                    ...fieldConfig,
+                    astNode: fieldConfig.astNode && {
+                        ...fieldConfig.astNode,
+                        directives: (_a = fieldConfig.astNode.directives) === null || _a === void 0 ? void 0 : _a.filter(directive => federationDirectives.includes(directive.name.value)),
+                    },
+                    extensions: {
+                        ...fieldConfig.extensions,
+                        directives: Object.fromEntries(Object.entries(((_b = fieldConfig.extensions) === null || _b === void 0 ? void 0 : _b.directives) || {}).filter(([key]) => federationDirectives.includes(key))),
+                    },
+                };
+            },
+        });
+    }
+}

package/package.json

@@ -1,19 +1,21 @@
 {
   "name": "@graphql-mesh/transform-federation",
-  "version": "1.0.0-alpha-3fc47d119.0",
+  "version": "1.0.0-alpha-20230420181317-a95037648",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "0.79.0-alpha-3fc47d119.0",
-    "@graphql-mesh/utils": "1.0.0-alpha-3fc47d119.0",
-    "graphql": "*"
+    "@graphql-mesh/types": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-mesh/utils": "1.0.0-alpha-20230420181317-a95037648",
+    "@graphql-tools/utils": "^9.2.1",
+    "graphql": "*",
+    "tslib": "^2.4.0"
   },
   "dependencies": {
-    "@apollo/subgraph": "2.0.5",
-    "@graphql-tools/delegate": "8.8.0",
-    "@graphql-tools/stitching-directives": "2.3.0",
-    "@graphql-tools/utils": "8.8.0",
-    "graphql-transform-federation": "2.2.0",
-    "tslib": "^2.4.0"
+    "@apollo/subgraph": "2.4.1",
+    "@graphql-mesh/string-interpolation": "0.4.4",
+    "@graphql-tools/delegate": "9.0.32",
+    "@graphql-tools/stitching-directives": "2.3.34",
+    "dset": "3.1.2",
+    "graphql-transform-federation": "2.2.0"
   },
   "repository": {
     "type": "git",
@@ -21,21 +23,28 @@
     "directory": "packages/transforms/federation"
   },
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
-    },
-    "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/index.d.cts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/typings/index.d.cts

@@ -0,0 +1,12 @@
+import { GraphQLSchema } from 'graphql';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
+import { SubschemaConfig } from '@graphql-tools/delegate';
+export default class FederationTransform implements MeshTransform {
+    private apiName;
+    private config;
+    private baseDir;
+    private importFn;
+    noWrap: boolean;
+    constructor({ apiName, baseDir, config, importFn, }: MeshTransformOptions<YamlConfig.Transform['federation']>);
+    transformSchema(schema: GraphQLSchema, rawSource: SubschemaConfig): GraphQLSchema;
+}

package/{index.d.ts → typings/index.d.ts}

@@ -1,11 +1,12 @@
 import { GraphQLSchema } from 'graphql';
-import { MeshTransform, YamlConfig, MeshTransformOptions } from '@graphql-mesh/types';
+import { MeshTransform, MeshTransformOptions, YamlConfig } from '@graphql-mesh/types';
 import { SubschemaConfig } from '@graphql-tools/delegate';
 export default class FederationTransform implements MeshTransform {
     private apiName;
     private config;
     private baseDir;
     private importFn;
-    constructor({ apiName, baseDir, config, importFn }: MeshTransformOptions<YamlConfig.Transform['federation']>);
+    noWrap: boolean;
+    constructor({ apiName, baseDir, config, importFn, }: MeshTransformOptions<YamlConfig.Transform['federation']>);
     transformSchema(schema: GraphQLSchema, rawSource: SubschemaConfig): GraphQLSchema;
 }

package/index.js

@@ -1,156 +0,0 @@
-'use strict';
-
-const graphql = require('graphql');
-const utils = require('@graphql-mesh/utils');
-const transformSdl_js = require('graphql-transform-federation/dist/transform-sdl.js');
-const types_js = require('@apollo/subgraph/dist/types.js');
-const utils$1 = require('@graphql-tools/utils');
-
-class FederationTransform {
-    constructor({ apiName, baseDir, config, importFn }) {
-        this.apiName = apiName;
-        this.config = config;
-        this.baseDir = baseDir;
-        this.importFn = importFn;
-    }
-    transformSchema(schema, rawSource) {
-        var _a, _b, _c, _d;
-        const federationConfig = {};
-        rawSource.merge = {};
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.types) {
-            const queryType = schema.getQueryType();
-            const queryTypeFields = queryType.getFields();
-            for (const type of this.config.types) {
-                rawSource.merge[type.name] = {};
-                const fields = {};
-                if ((_b = type.config) === null || _b === void 0 ? void 0 : _b.fields) {
-                    for (const field of type.config.fields) {
-                        fields[field.name] = field.config;
-                        rawSource.merge[type.name].fields = rawSource.merge[type.name].fields || {};
-                        rawSource.merge[type.name].fields[field.name] = rawSource.merge[type.name].fields[field.name] || {};
-                        if (field.config.requires) {
-                            rawSource.merge[type.name].fields[field.name].computed = true;
-                            rawSource.merge[type.name].fields[field.name].selectionSet = `{ ${field.config.requires} }`;
-                        }
-                    }
-                }
-                // If a field is a key field, it should be GraphQLID
-                if ((_c = type.config) === null || _c === void 0 ? void 0 : _c.keyFields) {
-                    rawSource.merge[type.name].selectionSet = `{ ${type.config.keyFields.join(' ')} }`;
-                    for (const fieldName of type.config.keyFields) {
-                        const objectType = schema.getType(type.name);
-                        if (objectType) {
-                            const existingType = objectType.getFields()[fieldName].type;
-                            objectType.getFields()[fieldName].type = graphql.isNonNullType(existingType)
-                                ? new graphql.GraphQLNonNull(graphql.GraphQLID)
-                                : graphql.GraphQLID;
-                        }
-                    }
-                }
-                let resolveReference;
-                if ((_d = type.config) === null || _d === void 0 ? void 0 : _d.resolveReference) {
-                    const resolveReferenceConfig = type.config.resolveReference;
-                    if (typeof resolveReferenceConfig === 'string') {
-                        const fn$ = utils.loadFromModuleExportExpression(resolveReferenceConfig, {
-                            cwd: this.baseDir,
-                            defaultExportName: 'default',
-                            importFn: this.importFn,
-                        });
-                        resolveReference = (...args) => fn$.then(fn => fn(...args));
-                    }
-                    else if (typeof resolveReferenceConfig === 'function') {
-                        resolveReference = resolveReferenceConfig;
-                    }
-                    else {
-                        const queryField = queryTypeFields[resolveReferenceConfig.queryFieldName];
-                        const keyArg = resolveReferenceConfig.keyArg || queryField.args[0].name;
-                        const keyField = type.config.keyFields[0];
-                        const isBatch = graphql.isListType(queryField.args.find(arg => arg.name === keyArg));
-                        resolveReference = async (root, context, info) => {
-                            const result = await context[this.apiName].Query[queryField.name]({
-                                root,
-                                ...(isBatch
-                                    ? {
-                                        key: root[keyField],
-                                        argsFromKeys: (keys) => ({
-                                            [keyArg]: keys,
-                                        }),
-                                    }
-                                    : {
-                                        args: {
-                                            [keyArg]: root[keyField],
-                                        },
-                                    }),
-                                context,
-                                info,
-                            });
-                            return {
-                                ...root,
-                                ...result,
-                            };
-                        };
-                    }
-                    rawSource.merge[type.name].resolve = resolveReference;
-                }
-                federationConfig[type.name] = {
-                    ...type.config,
-                    resolveReference,
-                    fields,
-                };
-            }
-        }
-        const entityTypes = Object.fromEntries(Object.entries(federationConfig)
-            .filter(([, { keyFields }]) => keyFields === null || keyFields === void 0 ? void 0 : keyFields.length)
-            .map(([objectName]) => {
-            const type = schema.getType(objectName);
-            if (!graphql.isObjectType(type)) {
-                throw new Error(`Type "${objectName}" is not an object type and can't have a key directive`);
-            }
-            return [objectName, type];
-        }));
-        const hasEntities = !!Object.keys(entityTypes).length;
-        const sdlWithFederationDirectives = transformSdl_js.addFederationAnnotations(utils$1.printSchemaWithDirectives(schema), federationConfig);
-        const schemaWithFederationQueryType = utils$1.mapSchema(schema, {
-            [utils$1.MapperKind.QUERY]: type => {
-                const config = type.toConfig();
-                return new graphql.GraphQLObjectType({
-                    ...config,
-                    fields: {
-                        ...config.fields,
-                        ...(hasEntities && {
-                            _entities: types_js.entitiesField,
-                            _service: {
-                                ...types_js.serviceField,
-                                resolve: () => ({ sdl: sdlWithFederationDirectives }),
-                            },
-                        }),
-                    },
-                });
-            },
-        });
-        const schemaWithUnionType = utils$1.mapSchema(schemaWithFederationQueryType, {
-            [utils$1.MapperKind.UNION_TYPE]: type => {
-                if (type.name === types_js.EntityType.name) {
-                    return new graphql.GraphQLUnionType({
-                        ...types_js.EntityType.toConfig(),
-                        types: Object.values(entityTypes),
-                    });
-                }
-                return type;
-            },
-        });
-        // Not using transformSchema since it will remove resolveReference
-        Object.entries(federationConfig).forEach(([objectName, currentFederationConfig]) => {
-            if (currentFederationConfig.resolveReference) {
-                const type = schemaWithUnionType.getType(objectName);
-                if (!graphql.isObjectType(type)) {
-                    throw new Error(`Type "${objectName}" is not an object type and can't have a resolveReference function`);
-                }
-                type.resolveObject = currentFederationConfig.resolveReference;
-            }
-        });
-        return schemaWithUnionType;
-    }
-}
-
-module.exports = FederationTransform;

package/index.mjs

@@ -1,154 +0,0 @@
-import { isNonNullType, GraphQLNonNull, GraphQLID, isListType, isObjectType, GraphQLObjectType, GraphQLUnionType } from 'graphql';
-import { loadFromModuleExportExpression } from '@graphql-mesh/utils';
-import { addFederationAnnotations } from 'graphql-transform-federation/dist/transform-sdl.js';
-import { entitiesField, serviceField, EntityType } from '@apollo/subgraph/dist/types.js';
-import { printSchemaWithDirectives, mapSchema, MapperKind } from '@graphql-tools/utils';
-
-class FederationTransform {
-    constructor({ apiName, baseDir, config, importFn }) {
-        this.apiName = apiName;
-        this.config = config;
-        this.baseDir = baseDir;
-        this.importFn = importFn;
-    }
-    transformSchema(schema, rawSource) {
-        var _a, _b, _c, _d;
-        const federationConfig = {};
-        rawSource.merge = {};
-        if ((_a = this.config) === null || _a === void 0 ? void 0 : _a.types) {
-            const queryType = schema.getQueryType();
-            const queryTypeFields = queryType.getFields();
-            for (const type of this.config.types) {
-                rawSource.merge[type.name] = {};
-                const fields = {};
-                if ((_b = type.config) === null || _b === void 0 ? void 0 : _b.fields) {
-                    for (const field of type.config.fields) {
-                        fields[field.name] = field.config;
-                        rawSource.merge[type.name].fields = rawSource.merge[type.name].fields || {};
-                        rawSource.merge[type.name].fields[field.name] = rawSource.merge[type.name].fields[field.name] || {};
-                        if (field.config.requires) {
-                            rawSource.merge[type.name].fields[field.name].computed = true;
-                            rawSource.merge[type.name].fields[field.name].selectionSet = `{ ${field.config.requires} }`;
-                        }
-                    }
-                }
-                // If a field is a key field, it should be GraphQLID
-                if ((_c = type.config) === null || _c === void 0 ? void 0 : _c.keyFields) {
-                    rawSource.merge[type.name].selectionSet = `{ ${type.config.keyFields.join(' ')} }`;
-                    for (const fieldName of type.config.keyFields) {
-                        const objectType = schema.getType(type.name);
-                        if (objectType) {
-                            const existingType = objectType.getFields()[fieldName].type;
-                            objectType.getFields()[fieldName].type = isNonNullType(existingType)
-                                ? new GraphQLNonNull(GraphQLID)
-                                : GraphQLID;
-                        }
-                    }
-                }
-                let resolveReference;
-                if ((_d = type.config) === null || _d === void 0 ? void 0 : _d.resolveReference) {
-                    const resolveReferenceConfig = type.config.resolveReference;
-                    if (typeof resolveReferenceConfig === 'string') {
-                        const fn$ = loadFromModuleExportExpression(resolveReferenceConfig, {
-                            cwd: this.baseDir,
-                            defaultExportName: 'default',
-                            importFn: this.importFn,
-                        });
-                        resolveReference = (...args) => fn$.then(fn => fn(...args));
-                    }
-                    else if (typeof resolveReferenceConfig === 'function') {
-                        resolveReference = resolveReferenceConfig;
-                    }
-                    else {
-                        const queryField = queryTypeFields[resolveReferenceConfig.queryFieldName];
-                        const keyArg = resolveReferenceConfig.keyArg || queryField.args[0].name;
-                        const keyField = type.config.keyFields[0];
-                        const isBatch = isListType(queryField.args.find(arg => arg.name === keyArg));
-                        resolveReference = async (root, context, info) => {
-                            const result = await context[this.apiName].Query[queryField.name]({
-                                root,
-                                ...(isBatch
-                                    ? {
-                                        key: root[keyField],
-                                        argsFromKeys: (keys) => ({
-                                            [keyArg]: keys,
-                                        }),
-                                    }
-                                    : {
-                                        args: {
-                                            [keyArg]: root[keyField],
-                                        },
-                                    }),
-                                context,
-                                info,
-                            });
-                            return {
-                                ...root,
-                                ...result,
-                            };
-                        };
-                    }
-                    rawSource.merge[type.name].resolve = resolveReference;
-                }
-                federationConfig[type.name] = {
-                    ...type.config,
-                    resolveReference,
-                    fields,
-                };
-            }
-        }
-        const entityTypes = Object.fromEntries(Object.entries(federationConfig)
-            .filter(([, { keyFields }]) => keyFields === null || keyFields === void 0 ? void 0 : keyFields.length)
-            .map(([objectName]) => {
-            const type = schema.getType(objectName);
-            if (!isObjectType(type)) {
-                throw new Error(`Type "${objectName}" is not an object type and can't have a key directive`);
-            }
-            return [objectName, type];
-        }));
-        const hasEntities = !!Object.keys(entityTypes).length;
-        const sdlWithFederationDirectives = addFederationAnnotations(printSchemaWithDirectives(schema), federationConfig);
-        const schemaWithFederationQueryType = mapSchema(schema, {
-            [MapperKind.QUERY]: type => {
-                const config = type.toConfig();
-                return new GraphQLObjectType({
-                    ...config,
-                    fields: {
-                        ...config.fields,
-                        ...(hasEntities && {
-                            _entities: entitiesField,
-                            _service: {
-                                ...serviceField,
-                                resolve: () => ({ sdl: sdlWithFederationDirectives }),
-                            },
-                        }),
-                    },
-                });
-            },
-        });
-        const schemaWithUnionType = mapSchema(schemaWithFederationQueryType, {
-            [MapperKind.UNION_TYPE]: type => {
-                if (type.name === EntityType.name) {
-                    return new GraphQLUnionType({
-                        ...EntityType.toConfig(),
-                        types: Object.values(entityTypes),
-                    });
-                }
-                return type;
-            },
-        });
-        // Not using transformSchema since it will remove resolveReference
-        Object.entries(federationConfig).forEach(([objectName, currentFederationConfig]) => {
-            if (currentFederationConfig.resolveReference) {
-                const type = schemaWithUnionType.getType(objectName);
-                if (!isObjectType(type)) {
-                    throw new Error(`Type "${objectName}" is not an object type and can't have a resolveReference function`);
-                }
-                type.resolveObject = currentFederationConfig.resolveReference;
-            }
-        });
-        return schemaWithUnionType;
-    }
-}
-
-export default FederationTransform;