@graphql-hive/cli
Version:
A CLI util to manage and control your GraphQL Hive
359 lines • 13 kB
JavaScript
"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const promises_1 = require("node:fs/promises");
const node_path_1 = require("node:path");
const graphql_1 = require("graphql");
const core_1 = require("@oclif/core");
const federation_composition_1 = require("@theguild/federation-composition");
const base_command_1 = tslib_1.__importDefault(require("../base-command"));
const gql_1 = require("../gql");
const config_1 = require("../helpers/config");
const schema_1 = require("../helpers/schema");
const validation_1 = require("../helpers/validation");
const CLI_SchemaComposeMutation = (0, gql_1.graphql)(/* GraphQL */ `
mutation CLI_SchemaComposeMutation($input: SchemaComposeInput!) {
schemaCompose(input: $input) {
__typename
... on SchemaComposeSuccess {
valid
compositionResult {
supergraphSdl
errors {
total
nodes {
message
}
}
}
}
... on SchemaComposeError {
message
}
}
}
`);
class Dev extends base_command_1.default {
async run() {
const { flags } = await this.parse(Dev);
const { unstable__forceLatest } = flags;
if (flags.service.length !== flags.url.length) {
this.error('Not every services has a matching url', {
exit: 1,
});
}
const isRemote = flags.remote === true;
const serviceInputs = flags.service.map((name, i) => {
const url = flags.url[i];
const sdl = flags.schema ? flags.schema[i] : undefined;
return {
name,
url,
sdl,
};
});
if (flags.watch === true) {
if (isRemote) {
const registry = this.ensure({
key: 'registry.endpoint',
legacyFlagName: 'registry',
args: flags,
defaultValue: config_1.graphqlEndpoint,
env: 'HIVE_REGISTRY',
});
const token = this.ensure({
key: 'registry.accessToken',
legacyFlagName: 'token',
args: flags,
env: 'HIVE_TOKEN',
});
void this.watch(flags.watchInterval, serviceInputs, services => this.compose({
services,
registry,
token,
write: flags.write,
unstable__forceLatest,
onError: message => {
this.fail(message);
},
}));
return;
}
void this.watch(flags.watchInterval, serviceInputs, services => this.composeLocally({
services,
write: flags.write,
onError: message => {
this.fail(message);
},
}));
return;
}
const services = await this.resolveServices(serviceInputs);
if (isRemote) {
const registry = this.ensure({
key: 'registry.endpoint',
legacyFlagName: 'registry',
args: flags,
defaultValue: config_1.graphqlEndpoint,
env: 'HIVE_REGISTRY',
});
const token = this.ensure({
key: 'registry.accessToken',
legacyFlagName: 'token',
args: flags,
env: 'HIVE_TOKEN',
});
return this.compose({
services,
registry,
token,
write: flags.write,
unstable__forceLatest,
onError: message => {
this.error(message, {
exit: 1,
});
},
});
}
return this.composeLocally({
services,
write: flags.write,
onError: message => {
this.error(message, {
exit: 1,
});
},
});
}
async composeLocally(input) {
const compositionResult = await new Promise((resolve, reject) => {
try {
resolve((0, federation_composition_1.composeServices)(input.services.map(service => ({
name: service.name,
url: service.url,
typeDefs: (0, graphql_1.parse)(service.sdl),
}))));
}
catch (error) {
reject(error);
}
}).catch(error => {
this.handleFetchError(error);
});
if ((0, federation_composition_1.compositionHasErrors)(compositionResult)) {
if (compositionResult.errors) {
schema_1.renderErrors.call(this, {
total: compositionResult.errors.length,
nodes: compositionResult.errors.map(error => ({
message: error.message,
})),
});
}
input.onError('Composition failed');
return;
}
if (typeof compositionResult.supergraphSdl !== 'string') {
input.onError('Composition successful but failed to get supergraph schema. Please try again later or contact support');
return;
}
this.success('Composition successful');
this.log(`Saving supergraph schema to ${input.write}`);
await (0, promises_1.writeFile)((0, node_path_1.resolve)(process.cwd(), input.write), compositionResult.supergraphSdl, 'utf-8');
}
async compose(input) {
const result = await this.registryApi(input.registry, input.token)
.request({
operation: CLI_SchemaComposeMutation,
variables: {
input: {
useLatestComposableVersion: !input.unstable__forceLatest,
services: input.services.map(service => ({
name: service.name,
url: service.url,
sdl: service.sdl,
})),
},
},
})
.catch(error => {
this.handleFetchError(error);
});
if (result.schemaCompose.__typename === 'SchemaComposeError') {
input.onError(result.schemaCompose.message);
return;
}
const { valid, compositionResult } = result.schemaCompose;
if (!valid) {
if (compositionResult.errors) {
schema_1.renderErrors.call(this, compositionResult.errors);
}
input.onError('Composition failed');
return;
}
if (typeof compositionResult.supergraphSdl !== 'string') {
input.onError('Composition successful but failed to get supergraph schema. Please try again later or contact support');
return;
}
this.success('Composition successful');
this.log(`Saving supergraph schema to ${input.write}`);
await (0, promises_1.writeFile)((0, node_path_1.resolve)(process.cwd(), input.write), compositionResult.supergraphSdl, 'utf-8');
}
async watch(watchInterval, serviceInputs, compose) {
this.info('Watch mode enabled');
let services = await this.resolveServices(serviceInputs);
await compose(services);
this.info('Watching for changes');
let resolveWatchMode;
const watchPromise = new Promise(resolve => {
resolveWatchMode = resolve;
});
let timeoutId;
const watch = async () => {
try {
const newServices = await this.resolveServices(serviceInputs);
if (newServices.some(service => services.find(s => s.name === service.name).sdl !== service.sdl)) {
this.info('Detected changes, recomposing');
await compose(newServices);
services = newServices;
}
}
catch (error) {
this.fail(String(error));
}
timeoutId = setTimeout(watch, watchInterval);
};
process.once('SIGINT', () => {
this.info('Exiting watch mode');
clearTimeout(timeoutId);
resolveWatchMode();
});
process.once('SIGTERM', () => {
this.info('Exiting watch mode');
clearTimeout(timeoutId);
resolveWatchMode();
});
void watch();
return watchPromise;
}
async resolveServices(services) {
return await Promise.all(services.map(async (input) => {
if (input.sdl) {
return {
name: input.name,
url: input.url,
sdl: await this.resolveSdlFromPath(input.sdl),
input: {
kind: 'file',
path: input.sdl,
},
};
}
return {
name: input.name,
url: input.url,
sdl: await this.resolveSdlFromUrl(input.url),
input: {
kind: 'url',
url: input.url,
},
};
}));
}
async resolveSdlFromPath(path) {
const sdl = await (0, schema_1.loadSchema)('introspection', path);
(0, validation_1.invariant)(typeof sdl === 'string' && sdl.length > 0, `Read empty schema from ${path}`);
return sdl;
}
async resolveSdlFromUrl(url) {
const sdl = await (0, schema_1.loadSchema)('federation-subgraph-introspection', url).catch(error => {
this.handleFetchError(error);
});
if (!sdl) {
throw new Error('Failed to introspect service');
}
return sdl;
}
}
Dev.description = [
'Develop and compose Supergraph with your local services.',
'Only available for Federation projects.',
'',
'Two modes are available:',
" 1. Local mode (default): Compose provided services locally. (Uses Hive's native Federation v2 composition)",
' 2. Remote mode: Perform composition remotely (according to project settings) using all services registered in the registry.',
'',
'Work in Progress: Please note that this command is still under development and may undergo changes in future releases',
].join('\n');
Dev.flags = {
'registry.endpoint': core_1.Flags.string({
description: 'registry endpoint',
dependsOn: ['remote'],
}),
/** @deprecated */
registry: core_1.Flags.string({
description: 'registry address (deprecated in favor of --registry.endpoint)',
deprecated: {
message: 'use --registry.endpoint instead',
version: '0.21.0',
},
dependsOn: ['remote'],
}),
'registry.accessToken': core_1.Flags.string({
description: 'registry access token',
dependsOn: ['remote'],
}),
/** @deprecated */
token: core_1.Flags.string({
description: 'api token (deprecated in favor of --registry.accessToken)',
deprecated: {
message: 'use --registry.accessToken instead',
version: '0.21.0',
},
dependsOn: ['remote'],
}),
service: core_1.Flags.string({
description: 'Service name',
required: true,
multiple: true,
helpValue: '<string>',
}),
url: core_1.Flags.string({
description: 'Service url',
required: true,
multiple: true,
helpValue: '<address>',
dependsOn: ['service'],
}),
schema: core_1.Flags.string({
description: 'Service sdl. If not provided, will be introspected from the service',
multiple: true,
helpValue: '<filepath>',
dependsOn: ['service'],
}),
watch: core_1.Flags.boolean({
description: 'Watch mode',
default: false,
}),
watchInterval: core_1.Flags.integer({
description: 'Watch interval in milliseconds',
default: 1000,
}),
write: core_1.Flags.string({
description: 'Where to save the supergraph schema file',
default: 'supergraph.graphql',
}),
remote: core_1.Flags.boolean({
// TODO: improve description
description: 'Compose provided services remotely',
default: false,
}),
unstable__forceLatest: core_1.Flags.boolean({
hidden: true,
description: 'Force the command to use the latest version of the CLI, not the latest composable version. ',
default: false,
dependsOn: ['remote'],
}),
};
exports.default = Dev;
//# sourceMappingURL=dev.js.map