@graphql-hive/cli/dist/commands/operations/check.js

A CLI util to manage and control your GraphQL Hive

"use strict";
Object.defineProperty(exports, "__esModule", { value: true });
const tslib_1 = require("tslib");
const graphql_1 = require("graphql");
const core_1 = require("@graphql-inspector/core");
const core_2 = require("@oclif/core");
const base_command_1 = tslib_1.__importDefault(require("../../base-command"));
const gql_1 = require("../../gql");
const config_1 = require("../../helpers/config");
const operations_1 = require("../../helpers/operations");
const fetchLatestVersionQuery = (0, gql_1.graphql)(/* GraphQL */ `
  query fetchLatestVersion {
    latestValidVersion {
      sdl
    }
  }
`);
class OperationsCheck extends base_command_1.default {
    async run() {
        var _a;
        try {
            const { flags, args } = await this.parse(OperationsCheck);
            await this.require(flags);
            const endpoint = this.ensure({
                key: 'registry.endpoint',
                args: flags,
                legacyFlagName: 'registry',
                defaultValue: config_1.graphqlEndpoint,
                env: 'HIVE_REGISTRY',
            });
            const accessToken = this.ensure({
                key: 'registry.accessToken',
                args: flags,
                legacyFlagName: 'token',
                env: 'HIVE_TOKEN',
            });
            const graphqlTag = flags.graphqlTag;
            const globalGraphqlTag = flags.globalGraphqlTag;
            const file = args.file;
            const operations = await (0, operations_1.loadOperations)(file, {
                normalize: false,
                pluckModules: graphqlTag === null || graphqlTag === void 0 ? void 0 : graphqlTag.map(tag => {
                    const [name, identifier] = tag.split(':');
                    return {
                        name,
                        identifier,
                    };
                }),
                pluckGlobalGqlIdentifierName: globalGraphqlTag,
            });
            if (operations.length === 0) {
                this.info('No operations found');
                this.exit(0);
                return;
            }
            const result = await this.registryApi(endpoint, accessToken).request({
                operation: fetchLatestVersionQuery,
            });
            const sdl = (_a = result.latestValidVersion) === null || _a === void 0 ? void 0 : _a.sdl;
            if (!sdl) {
                this.error('Could not find a published schema. Please publish a valid schema first.');
            }
            const schema = (0, graphql_1.buildSchema)(sdl, {
                assumeValidSDL: true,
                assumeValid: true,
            });
            if (!flags.apolloClient) {
                const detectedApolloDirectives = operations.some(s => s.content.includes('@client') || s.content.includes('@connection'));
                if (detectedApolloDirectives) {
                    this.warn('Apollo Client specific directives detected (@client, @connection). Please use the --apolloClient flag to enable support.');
                }
            }
            const invalidOperations = (0, core_1.validate)(schema, operations.map(s => new graphql_1.Source(s.content, s.location)), {
                apollo: flags.apolloClient === true,
            });
            const operationsWithErrors = invalidOperations.filter(o => o.errors.length > 0);
            if (operationsWithErrors.length === 0) {
                this.success(`All operations are valid (${operations.length})`);
                this.exit(0);
                return;
            }
            core_2.ux.styledHeader('Summary');
            this.log([
                `Total: ${operations.length}`,
                `Invalid: ${operationsWithErrors.length} (${Math.floor((operationsWithErrors.length / operations.length) * 100)}%)`,
                '',
            ].join('\n'));
            core_2.ux.styledHeader('Details');
            this.printInvalidDocuments(operationsWithErrors);
            this.exit(1);
        }
        catch (error) {
            if (error instanceof core_2.Errors.ExitError) {
                throw error;
            }
            else {
                this.fail('Failed to validate operations');
                this.handleFetchError(error);
            }
        }
    }
    printInvalidDocuments(invalidDocuments) {
        invalidDocuments.forEach(doc => {
            this.renderErrors(doc.source.name, doc.errors);
        });
    }
    renderErrors(sourceName, errors) {
        this.fail(sourceName);
        errors.forEach(e => {
            this.log(` - ${this.bolderize(e.message)}`);
        });
        this.log('');
    }
}
OperationsCheck.description = 'checks operations against a published schema';
OperationsCheck.flags = {
    'registry.endpoint': core_2.Flags.string({
        description: 'registry endpoint',
    }),
    /** @deprecated */
    registry: core_2.Flags.string({
        description: 'registry address',
        deprecated: {
            message: 'use --registry.endpoint instead',
            version: '0.21.0',
        },
    }),
    'registry.accessToken': core_2.Flags.string({
        description: 'registry access token',
    }),
    /** @deprecated */
    token: core_2.Flags.string({
        description: 'api token',
        deprecated: {
            message: 'use --registry.accessToken instead',
            version: '0.21.0',
        },
    }),
    require: core_2.Flags.string({
        description: 'Loads specific require.extensions before running the command',
        default: [],
        multiple: true,
    }),
    graphqlTag: core_2.Flags.string({
        description: [
            'Identify template literals containing GraphQL queries in JavaScript/TypeScript code. Supports multiple values.',
            'Examples:',
            '  --graphqlTag graphql-tag (Equivalent to: import gqlTagFunction from "graphql-tag")',
            '  --graphqlTag graphql:react-relay (Equivalent to: import { graphql } from "react-relay")',
        ].join('\n'),
        multiple: true,
    }),
    globalGraphqlTag: core_2.Flags.string({
        description: [
            'Allows to use a global identifier instead of a module import. Similar to --graphqlTag.',
            'Examples:',
            '  --globalGraphqlTag gql (Supports: export const meQuery = gql`{ me { id } }`)',
            '  --globalGraphqlTag graphql (Supports: export const meQuery = graphql`{ me { id } }`)',
        ].join('\n'),
        multiple: true,
    }),
    apolloClient: core_2.Flags.boolean({
        description: 'Supports Apollo Client specific directives',
        default: false,
    }),
};
OperationsCheck.args = {
    file: core_2.Args.string({
        name: 'file',
        required: true,
        description: 'Glob pattern to find the operations',
        hidden: false,
    }),
};
exports.default = OperationsCheck;
//# sourceMappingURL=check.js.map