@graphql-mesh/compose-cli 0.4.0 → 0.4.1-alpha-20240626143434-7cd2ddcf1e46bd3f52ea1e6276c1d9beeb5171a4

package/cjs/getComposedSchemaFromConfig.js

@@ -1,9 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.getComposedSchemaFromConfig = void 0;
+exports.getComposedSchemaFromConfig = getComposedSchemaFromConfig;
+const graphql_1 = require("graphql");
 const fusion_composition_1 = require("@graphql-mesh/fusion-composition");
 const graphql_file_loader_1 = require("@graphql-tools/graphql-file-loader");
 const load_1 = require("@graphql-tools/load");
+const schema_1 = require("@graphql-tools/schema");
+const utils_1 = require("@graphql-tools/utils");
 const fetch_1 = require("@whatwg-node/fetch");
 async function getComposedSchemaFromConfig(config, logger) {
     const ctx = {
@@ -20,7 +23,8 @@ async function getComposedSchemaFromConfig(config, logger) {
             subgraphSchema = await schema$;
         }
         catch (e) {
-            throw new Error(`Failed to load subgraph ${subgraphName} - ${e.stack}`);
+            log.error(`Failed to load subgraph ${subgraphName}`);
+            throw e;
         }
         return {
             name: subgraphName,
@@ -38,15 +42,41 @@ async function getComposedSchemaFromConfig(config, logger) {
         });
         additionalTypeDefs = result.map(r => r.document || r.rawSDL);
     }
-    let composedSchema = (0, fusion_composition_1.composeSubgraphs)(subgraphConfigsForComposition, {
-        typeDefs: additionalTypeDefs,
-    });
-    if (config.transforms?.length) {
-        logger.info('Applying transforms');
-        for (const transform of config.transforms) {
-            composedSchema = transform(composedSchema);
+    const result = (0, fusion_composition_1.composeSubgraphs)(subgraphConfigsForComposition);
+    if (result.errors?.length) {
+        throw new Error(`Failed to compose subgraphs; \n${result.errors.map(e => `- ${e.message}`).join('\n')}`);
+    }
+    if (config.subgraph) {
+        const subgraph = result.annotatedSubgraphs.find(sg => sg.name === config.subgraph);
+        if (!subgraph) {
+            throw new Error(`Subgraph ${config.subgraph} not found`);
         }
+        return (0, graphql_1.print)(subgraph.typeDefs);
+    }
+    if (!result.supergraphSdl) {
+        throw new Error(`Unknown error: composed schema is empty`);
     }
-    return composedSchema;
+    if (additionalTypeDefs?.length || config.transforms?.length) {
+        let composedSchema = (0, graphql_1.buildSchema)(result.supergraphSdl, {
+            noLocation: true,
+            assumeValid: true,
+            assumeValidSDL: true,
+        });
+        if (additionalTypeDefs?.length) {
+            composedSchema = (0, schema_1.mergeSchemas)({
+                schemas: [composedSchema],
+                typeDefs: additionalTypeDefs,
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        if (config.transforms?.length) {
+            logger.info('Applying transforms');
+            for (const transform of config.transforms) {
+                composedSchema = transform(composedSchema);
+            }
+        }
+        return (0, utils_1.printSchemaWithDirectives)(composedSchema);
+    }
+    return result.supergraphSdl;
 }
-exports.getComposedSchemaFromConfig = getComposedSchemaFromConfig;

package/cjs/loadGraphQLHTTPSubgraph.js

@@ -1,8 +1,8 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.loadGraphQLHTTPSubgraph = void 0;
+exports.loadGraphQLHTTPSubgraph = loadGraphQLHTTPSubgraph;
 const graphql_1 = require("graphql");
-function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, spec = false, transportKind = 'http', }) {
+function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, federation = false, transportKind = 'http', }) {
     return (ctx) => {
         let schema$;
         function handleFetchedSchema(schema) {
@@ -10,7 +10,7 @@ function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQuer
                 kind: transportKind,
                 subgraph: subgraphName,
                 location: endpoint,
-                headers: operationHeaders,
+                headers: operationHeaders ? Object.entries(operationHeaders) : undefined,
                 options: {
                     method,
                     useGETForQueries,
@@ -35,7 +35,7 @@ function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQuer
                 kind: transportKind,
                 subgraph: subgraphName,
                 location: endpoint,
-                headers: operationHeaders,
+                headers: operationHeaders ? Object.entries(operationHeaders) : undefined,
                 options: {
                     method,
                     useGETForQueries,
@@ -46,50 +46,58 @@ function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQuer
             }, schema));
         }
         else {
-            switch (spec) {
-                case false:
-                    schema$ = ctx
-                        .fetch(endpoint, {
-                        method: method || (useGETForQueries ? 'GET' : 'POST'),
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            query: (0, graphql_1.getIntrospectionQuery)(),
-                        }),
-                    })
-                        .then(res => {
-                        assertResponseOk(res);
-                        return res.json();
-                    })
-                        .then((result) => (0, graphql_1.buildClientSchema)(result.data, {
-                        assumeValid: true,
-                    }));
-                    break;
-                case 'federation':
-                    schema$ = ctx
-                        .fetch(endpoint, {
-                        method: method || (useGETForQueries ? 'GET' : 'POST'),
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            query: federationIntrospectionQuery,
-                        }),
-                    })
-                        .then(res => {
-                        assertResponseOk(res);
-                        return res.text();
-                    })
-                        .then(sdl => (0, graphql_1.buildSchema)(sdl, {
-                        assumeValidSDL: true,
-                        assumeValid: true,
-                        noLocation: true,
-                    }));
-                    break;
-                default:
-                    throw new Error(`Unsupported spec: ${spec}`);
-            }
+            const fetchAsRegular = () => ctx
+                .fetch(endpoint, {
+                method: method || (useGETForQueries ? 'GET' : 'POST'),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query: (0, graphql_1.getIntrospectionQuery)(),
+                }),
+            })
+                .then(res => {
+                assertResponseOk(res);
+                return res.json();
+            })
+                .then((result) => (0, graphql_1.buildClientSchema)(result.data, {
+                assumeValid: true,
+            }))
+                .then(schema => {
+                const queryType = schema.getQueryType();
+                const queryFields = queryType?.getFields();
+                if (queryFields._service) {
+                    const serviceType = (0, graphql_1.getNamedType)(queryFields._service.type);
+                    if ((0, graphql_1.isObjectType)(serviceType)) {
+                        const serviceTypeFields = serviceType.getFields();
+                        if (serviceTypeFields.sdl) {
+                            return fetchAsFederation();
+                        }
+                    }
+                }
+                return schema;
+            });
+            const fetchAsFederation = () => ctx
+                .fetch(endpoint, {
+                method: method || (useGETForQueries ? 'GET' : 'POST'),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query: federationIntrospectionQuery,
+                }),
+            })
+                .then(res => {
+                assertResponseOk(res);
+                return res.json();
+            })
+                .then((result) => result?.data?._service?.sdl)
+                .then(sdl => (0, graphql_1.buildSchema)(sdl, {
+                assumeValidSDL: true,
+                assumeValid: true,
+                noLocation: true,
+            }));
+            schema$ = federation ? fetchAsFederation() : fetchAsRegular();
         }
         schema$ = schema$.then(handleFetchedSchema);
         return {
@@ -98,12 +106,27 @@ function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQuer
         };
     };
 }
-exports.loadGraphQLHTTPSubgraph = loadGraphQLHTTPSubgraph;
+const transportDirective = new graphql_1.GraphQLDirective({
+    name: 'transport',
+    isRepeatable: true,
+    locations: [graphql_1.DirectiveLocation.SCHEMA],
+    args: {
+        kind: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        subgraph: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        location: { type: new graphql_1.GraphQLNonNull(graphql_1.GraphQLString) },
+        headers: { type: new graphql_1.GraphQLList(new graphql_1.GraphQLList(graphql_1.GraphQLString)) },
+        options: { type: new graphql_1.GraphQLScalarType({ name: 'TransportOptions' }) },
+    },
+});
 function addAnnotations(transportEntry, schema) {
     const schemaExtensions = (schema.extensions ||= {});
     schemaExtensions.directives ||= {};
     schemaExtensions.directives.transport = transportEntry;
-    return schema;
+    const schemaConfig = schema.toConfig();
+    return new graphql_1.GraphQLSchema({
+        ...schemaConfig,
+        directives: [...schemaConfig.directives, transportDirective],
+    });
 }
 const federationIntrospectionQuery = /* GraphQL */ `
   query GetFederationInfo {

package/cjs/run.js

@@ -23,7 +23,7 @@ var __importStar = (this && this.__importStar) || function (mod) {
     return result;
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.run = void 0;
+exports.run = run;
 require("tsx/cjs"); // support importing typescript configs in CommonJS
 require("tsx/esm"); // support importing typescript configs in ESM
 require("dotenv/config"); // inject dotenv options to process.env
@@ -34,12 +34,12 @@ const path_1 = require("path");
 const graphql_1 = require("graphql");
 const extra_typings_1 = require("@commander-js/extra-typings");
 const utils_1 = require("@graphql-mesh/utils");
-const utils_2 = require("@graphql-tools/utils");
 const getComposedSchemaFromConfig_js_1 = require("./getComposedSchemaFromConfig.js");
 let program = new extra_typings_1.Command()
     .addOption(new extra_typings_1.Option('-c, --config-path <path>', 'path to the configuration file')
     .env('CONFIG_PATH')
     .default('mesh.config.ts'))
+    .option('--subgraph <name>', 'name of the subgraph to compose')
     .option('-o, --output <path>', 'path to the output file');
 async function run({ log: rootLog = new utils_1.DefaultLogger(), productName = 'Mesh Compose', productDescription = 'compose a GraphQL federated schema from any API service(s)', binName = 'mesh-compose', version, }) {
     program = program.name(binName).description(productDescription);
@@ -76,15 +76,14 @@ async function run({ log: rootLog = new utils_1.DefaultLogger(), productName = '
         ...opts,
     };
     log.info('Composing');
-    const fusiongraphSchema = await (0, getComposedSchemaFromConfig_js_1.getComposedSchemaFromConfig)(config, log);
-    const fusiongraph = (0, utils_2.printSchemaWithDirectives)(fusiongraphSchema);
+    const supergraphSdl = await (0, getComposedSchemaFromConfig_js_1.getComposedSchemaFromConfig)(config, log);
     let output = config.output;
     if (!output) {
         if (typeof process === 'object') {
-            process.stdout.write(fusiongraph + '\n');
+            process.stdout.write(supergraphSdl + '\n');
         }
         else {
-            console.log(fusiongraph);
+            console.log(supergraphSdl);
         }
         log.info('Done!');
         return;
@@ -93,13 +92,13 @@ async function run({ log: rootLog = new utils_1.DefaultLogger(), productName = '
     output = (0, path_1.isAbsolute)(output) ? output : (0, path_1.join)(process.cwd(), output);
     let writtenData;
     if (output.endsWith('.json')) {
-        writtenData = JSON.stringify((0, graphql_1.parse)(fusiongraph, { noLocation: true }), null, 2);
+        writtenData = JSON.stringify((0, graphql_1.parse)(supergraphSdl, { noLocation: true }), null, 2);
     }
     else if (output.endsWith('.graphql') ||
         output.endsWith('.gql') ||
         output.endsWith('.graphqls') ||
         output.endsWith('.gqls')) {
-        writtenData = fusiongraph;
+        writtenData = supergraphSdl;
     }
     else if (output.endsWith('.ts') ||
         output.endsWith('.cts') ||
@@ -107,7 +106,7 @@ async function run({ log: rootLog = new utils_1.DefaultLogger(), productName = '
         output.endsWith('.js') ||
         output.endsWith('.cjs') ||
         output.endsWith('.mjs')) {
-        writtenData = `export default ${JSON.stringify(fusiongraph)}`;
+        writtenData = `export default ${JSON.stringify(supergraphSdl)}`;
     }
     else {
         throw new Error(`Unsupported file extension for ${output}`);
@@ -115,4 +114,3 @@ async function run({ log: rootLog = new utils_1.DefaultLogger(), productName = '
     await fs_1.promises.writeFile(output, writtenData, 'utf8');
     log.info('Done!');
 }
-exports.run = run;

package/cjs/types.js

@@ -1,10 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.defineConfig = void 0;
+exports.defineConfig = defineConfig;
 /**
  * Type helper for defining the config.
  */
 function defineConfig(config) {
     return config;
 }
-exports.defineConfig = defineConfig;

package/esm/getComposedSchemaFromConfig.js

@@ -1,6 +1,9 @@
+import { buildSchema, print } from 'graphql';
 import { composeSubgraphs } from '@graphql-mesh/fusion-composition';
 import { GraphQLFileLoader } from '@graphql-tools/graphql-file-loader';
 import { loadTypedefs } from '@graphql-tools/load';
+import { mergeSchemas } from '@graphql-tools/schema';
+import { printSchemaWithDirectives } from '@graphql-tools/utils';
 import { fetch as defaultFetch } from '@whatwg-node/fetch';
 export async function getComposedSchemaFromConfig(config, logger) {
     const ctx = {
@@ -17,7 +20,8 @@ export async function getComposedSchemaFromConfig(config, logger) {
             subgraphSchema = await schema$;
         }
         catch (e) {
-            throw new Error(`Failed to load subgraph ${subgraphName} - ${e.stack}`);
+            log.error(`Failed to load subgraph ${subgraphName}`);
+            throw e;
         }
         return {
             name: subgraphName,
@@ -35,14 +39,41 @@ export async function getComposedSchemaFromConfig(config, logger) {
         });
         additionalTypeDefs = result.map(r => r.document || r.rawSDL);
     }
-    let composedSchema = composeSubgraphs(subgraphConfigsForComposition, {
-        typeDefs: additionalTypeDefs,
-    });
-    if (config.transforms?.length) {
-        logger.info('Applying transforms');
-        for (const transform of config.transforms) {
-            composedSchema = transform(composedSchema);
+    const result = composeSubgraphs(subgraphConfigsForComposition);
+    if (result.errors?.length) {
+        throw new Error(`Failed to compose subgraphs; \n${result.errors.map(e => `- ${e.message}`).join('\n')}`);
+    }
+    if (config.subgraph) {
+        const subgraph = result.annotatedSubgraphs.find(sg => sg.name === config.subgraph);
+        if (!subgraph) {
+            throw new Error(`Subgraph ${config.subgraph} not found`);
+        }
+        return print(subgraph.typeDefs);
+    }
+    if (!result.supergraphSdl) {
+        throw new Error(`Unknown error: composed schema is empty`);
+    }
+    if (additionalTypeDefs?.length || config.transforms?.length) {
+        let composedSchema = buildSchema(result.supergraphSdl, {
+            noLocation: true,
+            assumeValid: true,
+            assumeValidSDL: true,
+        });
+        if (additionalTypeDefs?.length) {
+            composedSchema = mergeSchemas({
+                schemas: [composedSchema],
+                typeDefs: additionalTypeDefs,
+                assumeValid: true,
+                assumeValidSDL: true,
+            });
+        }
+        if (config.transforms?.length) {
+            logger.info('Applying transforms');
+            for (const transform of config.transforms) {
+                composedSchema = transform(composedSchema);
+            }
         }
+        return printSchemaWithDirectives(composedSchema);
     }
-    return composedSchema;
+    return result.supergraphSdl;
 }

package/esm/loadGraphQLHTTPSubgraph.js

@@ -1,5 +1,5 @@
-import { buildClientSchema, buildSchema, getIntrospectionQuery, } from 'graphql';
-export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, spec = false, transportKind = 'http', }) {
+import { buildClientSchema, buildSchema, DirectiveLocation, getIntrospectionQuery, getNamedType, GraphQLDirective, GraphQLList, GraphQLNonNull, GraphQLScalarType, GraphQLSchema, GraphQLString, isObjectType, } from 'graphql';
+export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, federation = false, transportKind = 'http', }) {
     return (ctx) => {
         let schema$;
         function handleFetchedSchema(schema) {
@@ -7,7 +7,7 @@ export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGET
                 kind: transportKind,
                 subgraph: subgraphName,
                 location: endpoint,
-                headers: operationHeaders,
+                headers: operationHeaders ? Object.entries(operationHeaders) : undefined,
                 options: {
                     method,
                     useGETForQueries,
@@ -32,7 +32,7 @@ export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGET
                 kind: transportKind,
                 subgraph: subgraphName,
                 location: endpoint,
-                headers: operationHeaders,
+                headers: operationHeaders ? Object.entries(operationHeaders) : undefined,
                 options: {
                     method,
                     useGETForQueries,
@@ -43,50 +43,58 @@ export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGET
             }, schema));
         }
         else {
-            switch (spec) {
-                case false:
-                    schema$ = ctx
-                        .fetch(endpoint, {
-                        method: method || (useGETForQueries ? 'GET' : 'POST'),
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            query: getIntrospectionQuery(),
-                        }),
-                    })
-                        .then(res => {
-                        assertResponseOk(res);
-                        return res.json();
-                    })
-                        .then((result) => buildClientSchema(result.data, {
-                        assumeValid: true,
-                    }));
-                    break;
-                case 'federation':
-                    schema$ = ctx
-                        .fetch(endpoint, {
-                        method: method || (useGETForQueries ? 'GET' : 'POST'),
-                        headers: {
-                            'Content-Type': 'application/json',
-                        },
-                        body: JSON.stringify({
-                            query: federationIntrospectionQuery,
-                        }),
-                    })
-                        .then(res => {
-                        assertResponseOk(res);
-                        return res.text();
-                    })
-                        .then(sdl => buildSchema(sdl, {
-                        assumeValidSDL: true,
-                        assumeValid: true,
-                        noLocation: true,
-                    }));
-                    break;
-                default:
-                    throw new Error(`Unsupported spec: ${spec}`);
-            }
+            const fetchAsRegular = () => ctx
+                .fetch(endpoint, {
+                method: method || (useGETForQueries ? 'GET' : 'POST'),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query: getIntrospectionQuery(),
+                }),
+            })
+                .then(res => {
+                assertResponseOk(res);
+                return res.json();
+            })
+                .then((result) => buildClientSchema(result.data, {
+                assumeValid: true,
+            }))
+                .then(schema => {
+                const queryType = schema.getQueryType();
+                const queryFields = queryType?.getFields();
+                if (queryFields._service) {
+                    const serviceType = getNamedType(queryFields._service.type);
+                    if (isObjectType(serviceType)) {
+                        const serviceTypeFields = serviceType.getFields();
+                        if (serviceTypeFields.sdl) {
+                            return fetchAsFederation();
+                        }
+                    }
+                }
+                return schema;
+            });
+            const fetchAsFederation = () => ctx
+                .fetch(endpoint, {
+                method: method || (useGETForQueries ? 'GET' : 'POST'),
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({
+                    query: federationIntrospectionQuery,
+                }),
+            })
+                .then(res => {
+                assertResponseOk(res);
+                return res.json();
+            })
+                .then((result) => result?.data?._service?.sdl)
+                .then(sdl => buildSchema(sdl, {
+                assumeValidSDL: true,
+                assumeValid: true,
+                noLocation: true,
+            }));
+            schema$ = federation ? fetchAsFederation() : fetchAsRegular();
         }
         schema$ = schema$.then(handleFetchedSchema);
         return {
@@ -95,11 +103,27 @@ export function loadGraphQLHTTPSubgraph(subgraphName, { endpoint, method, useGET
         };
     };
 }
+const transportDirective = new GraphQLDirective({
+    name: 'transport',
+    isRepeatable: true,
+    locations: [DirectiveLocation.SCHEMA],
+    args: {
+        kind: { type: new GraphQLNonNull(GraphQLString) },
+        subgraph: { type: new GraphQLNonNull(GraphQLString) },
+        location: { type: new GraphQLNonNull(GraphQLString) },
+        headers: { type: new GraphQLList(new GraphQLList(GraphQLString)) },
+        options: { type: new GraphQLScalarType({ name: 'TransportOptions' }) },
+    },
+});
 function addAnnotations(transportEntry, schema) {
     const schemaExtensions = (schema.extensions ||= {});
     schemaExtensions.directives ||= {};
     schemaExtensions.directives.transport = transportEntry;
-    return schema;
+    const schemaConfig = schema.toConfig();
+    return new GraphQLSchema({
+        ...schemaConfig,
+        directives: [...schemaConfig.directives, transportDirective],
+    });
 }
 const federationIntrospectionQuery = /* GraphQL */ `
   query GetFederationInfo {

package/esm/run.js

@@ -8,12 +8,12 @@ import { isAbsolute, join, resolve } from 'path';
 import { parse } from 'graphql';
 import { Command, Option } from '@commander-js/extra-typings';
 import { DefaultLogger } from '@graphql-mesh/utils';
-import { printSchemaWithDirectives } from '@graphql-tools/utils';
 import { getComposedSchemaFromConfig } from './getComposedSchemaFromConfig.js';
 let program = new Command()
     .addOption(new Option('-c, --config-path <path>', 'path to the configuration file')
     .env('CONFIG_PATH')
     .default('mesh.config.ts'))
+    .option('--subgraph <name>', 'name of the subgraph to compose')
     .option('-o, --output <path>', 'path to the output file');
 export async function run({ log: rootLog = new DefaultLogger(), productName = 'Mesh Compose', productDescription = 'compose a GraphQL federated schema from any API service(s)', binName = 'mesh-compose', version, }) {
     program = program.name(binName).description(productDescription);
@@ -50,15 +50,14 @@ export async function run({ log: rootLog = new DefaultLogger(), productName = 'M
         ...opts,
     };
     log.info('Composing');
-    const fusiongraphSchema = await getComposedSchemaFromConfig(config, log);
-    const fusiongraph = printSchemaWithDirectives(fusiongraphSchema);
+    const supergraphSdl = await getComposedSchemaFromConfig(config, log);
     let output = config.output;
     if (!output) {
         if (typeof process === 'object') {
-            process.stdout.write(fusiongraph + '\n');
+            process.stdout.write(supergraphSdl + '\n');
         }
         else {
-            console.log(fusiongraph);
+            console.log(supergraphSdl);
         }
         log.info('Done!');
         return;
@@ -67,13 +66,13 @@ export async function run({ log: rootLog = new DefaultLogger(), productName = 'M
     output = isAbsolute(output) ? output : join(process.cwd(), output);
     let writtenData;
     if (output.endsWith('.json')) {
-        writtenData = JSON.stringify(parse(fusiongraph, { noLocation: true }), null, 2);
+        writtenData = JSON.stringify(parse(supergraphSdl, { noLocation: true }), null, 2);
     }
     else if (output.endsWith('.graphql') ||
         output.endsWith('.gql') ||
         output.endsWith('.graphqls') ||
         output.endsWith('.gqls')) {
-        writtenData = fusiongraph;
+        writtenData = supergraphSdl;
     }
     else if (output.endsWith('.ts') ||
         output.endsWith('.cts') ||
@@ -81,7 +80,7 @@ export async function run({ log: rootLog = new DefaultLogger(), productName = 'M
         output.endsWith('.js') ||
         output.endsWith('.cjs') ||
         output.endsWith('.mjs')) {
-        writtenData = `export default ${JSON.stringify(fusiongraph)}`;
+        writtenData = `export default ${JSON.stringify(supergraphSdl)}`;
     }
     else {
         throw new Error(`Unsupported file extension for ${output}`);

package/package.json

@@ -1,17 +1,18 @@
 {
   "name": "@graphql-mesh/compose-cli",
-  "version": "0.4.0",
+  "version": "0.4.1-alpha-20240626143434-7cd2ddcf1e46bd3f52ea1e6276c1d9beeb5171a4",
   "sideEffects": false,
   "peerDependencies": {
-    "@graphql-mesh/types": "^0.98.8",
+    "@graphql-mesh/types": "0.98.9-alpha-20240626143434-7cd2ddcf1e46bd3f52ea1e6276c1d9beeb5171a4",
     "graphql": "*"
   },
   "dependencies": {
     "@commander-js/extra-typings": "^12.0.1",
-    "@graphql-mesh/fusion-composition": "^0.0.6",
-    "@graphql-mesh/utils": "^0.98.8",
+    "@graphql-mesh/fusion-composition": "0.0.7-alpha-20240626143434-7cd2ddcf1e46bd3f52ea1e6276c1d9beeb5171a4",
+    "@graphql-mesh/utils": "0.98.9-alpha-20240626143434-7cd2ddcf1e46bd3f52ea1e6276c1d9beeb5171a4",
     "@graphql-tools/graphql-file-loader": "8.0.1",
     "@graphql-tools/load": "^8.0.1",
+    "@graphql-tools/schema": "^10.0.4",
     "@graphql-tools/utils": "^10.2.1",
     "@whatwg-node/fetch": "^0.9.14",
     "commander": "^12.0.0",

package/typings/getComposedSchemaFromConfig.d.cts

@@ -1,4 +1,3 @@
-import { GraphQLSchema } from 'graphql';
 import { Logger } from '@graphql-mesh/types';
 import { MeshComposeCLIConfig } from './types.cjs';
-export declare function getComposedSchemaFromConfig(config: MeshComposeCLIConfig, logger: Logger): Promise<GraphQLSchema>;
+export declare function getComposedSchemaFromConfig(config: MeshComposeCLIConfig, logger: Logger): Promise<string>;

package/typings/getComposedSchemaFromConfig.d.ts

@@ -1,4 +1,3 @@
-import { GraphQLSchema } from 'graphql';
 import { Logger } from '@graphql-mesh/types';
 import { MeshComposeCLIConfig } from './types.js';
-export declare function getComposedSchemaFromConfig(config: MeshComposeCLIConfig, logger: Logger): Promise<GraphQLSchema>;
+export declare function getComposedSchemaFromConfig(config: MeshComposeCLIConfig, logger: Logger): Promise<string>;

package/typings/loadGraphQLHTTPSubgraph.d.cts

@@ -45,11 +45,11 @@ export interface GraphQLSubgraphLoaderHTTPConfiguration {
      */
     schemaHeaders?: any;
     /**
-     * Subgraph spec
+     * Federation Subgraph
      *
      * @default false
      */
-    spec?: 'federation' | 'stitching' | 'fusion' | false;
+    federation?: boolean;
     /**
      * Transport kind
      *
@@ -57,4 +57,4 @@ export interface GraphQLSubgraphLoaderHTTPConfiguration {
      */
     transportKind?: 'http';
 }
-export declare function loadGraphQLHTTPSubgraph(subgraphName: string, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, spec, transportKind, }: GraphQLSubgraphLoaderHTTPConfiguration): MeshComposeCLISourceHandlerDef;
+export declare function loadGraphQLHTTPSubgraph(subgraphName: string, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, federation, transportKind, }: GraphQLSubgraphLoaderHTTPConfiguration): MeshComposeCLISourceHandlerDef;

package/typings/loadGraphQLHTTPSubgraph.d.ts

@@ -45,11 +45,11 @@ export interface GraphQLSubgraphLoaderHTTPConfiguration {
      */
     schemaHeaders?: any;
     /**
-     * Subgraph spec
+     * Federation Subgraph
      *
      * @default false
      */
-    spec?: 'federation' | 'stitching' | 'fusion' | false;
+    federation?: boolean;
     /**
      * Transport kind
      *
@@ -57,4 +57,4 @@ export interface GraphQLSubgraphLoaderHTTPConfiguration {
      */
     transportKind?: 'http';
 }
-export declare function loadGraphQLHTTPSubgraph(subgraphName: string, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, spec, transportKind, }: GraphQLSubgraphLoaderHTTPConfiguration): MeshComposeCLISourceHandlerDef;
+export declare function loadGraphQLHTTPSubgraph(subgraphName: string, { endpoint, method, useGETForQueries, operationHeaders, credentials, retry, timeout, source, schemaHeaders, federation, transportKind, }: GraphQLSubgraphLoaderHTTPConfiguration): MeshComposeCLISourceHandlerDef;

package/typings/run.d.cts

@@ -5,6 +5,7 @@ import { Command } from '@commander-js/extra-typings';
 import { Logger } from '@graphql-mesh/types';
 declare let program: Command<[], {
     configPath?: string;
+    subgraph?: string;
     output?: string;
 }>;
 export interface RunOptions extends ReturnType<typeof program.opts> {

package/typings/run.d.ts

@@ -5,6 +5,7 @@ import { Command } from '@commander-js/extra-typings';
 import { Logger } from '@graphql-mesh/types';
 declare let program: Command<[], {
     configPath?: string;
+    subgraph?: string;
     output?: string;
 }>;
 export interface RunOptions extends ReturnType<typeof program.opts> {

package/typings/types.d.cts

@@ -1,7 +1,8 @@
 import { DocumentNode, GraphQLSchema } from 'graphql';
 import { Logger } from '@graphql-mesh/types';
 import { fetch as defaultFetch } from '@whatwg-node/fetch';
-export interface MeshComposeCLIConfig {
+import { ComposeSubgraphsOptions } from '@graphql-mesh/fusion-composition';
+export interface MeshComposeCLIConfig extends ComposeSubgraphsOptions {
     /**
      * The output destination of the resulting composed GraphQL schema.
      * By default, the CLI will write the result to stdout.
@@ -10,6 +11,7 @@ export interface MeshComposeCLIConfig {
     subgraphs: MeshComposeCLISubgraphConfig[];
     transforms?: MeshComposeCLITransformConfig[];
     additionalTypeDefs?: string | DocumentNode | (string | DocumentNode)[];
+    subgraph?: string;
     fetch?: typeof defaultFetch;
     cwd?: string;
 }

package/typings/types.d.ts

@@ -1,7 +1,8 @@
 import { DocumentNode, GraphQLSchema } from 'graphql';
 import { Logger } from '@graphql-mesh/types';
 import { fetch as defaultFetch } from '@whatwg-node/fetch';
-export interface MeshComposeCLIConfig {
+import { ComposeSubgraphsOptions } from '@graphql-mesh/fusion-composition';
+export interface MeshComposeCLIConfig extends ComposeSubgraphsOptions {
     /**
      * The output destination of the resulting composed GraphQL schema.
      * By default, the CLI will write the result to stdout.
@@ -10,6 +11,7 @@ export interface MeshComposeCLIConfig {
     subgraphs: MeshComposeCLISubgraphConfig[];
     transforms?: MeshComposeCLITransformConfig[];
     additionalTypeDefs?: string | DocumentNode | (string | DocumentNode)[];
+    subgraph?: string;
     fetch?: typeof defaultFetch;
     cwd?: string;
 }