@graphql-inspector/validate-command 0.0.0-PLACEHOLDER

package/index.d.ts

@@ -0,0 +1,34 @@
+import { GlobalArgs, CommandFactory } from '@graphql-inspector/commands';
+import { Source as DocumentSource } from '@graphql-tools/utils';
+import { GraphQLSchema } from 'graphql';
+export { CommandFactory };
+export declare function handler({ schema, documents, strictFragments, maxDepth, apollo, keepClientFields, failOnDeprecated, filter, onlyErrors, relativePaths, output, silent, }: {
+    schema: GraphQLSchema;
+    documents: DocumentSource[];
+    failOnDeprecated: boolean;
+    strictFragments: boolean;
+    apollo: boolean;
+    keepClientFields: boolean;
+    maxDepth?: number;
+    filter?: string[];
+    onlyErrors?: boolean;
+    relativePaths?: boolean;
+    output?: string;
+    silent?: boolean;
+}): void;
+declare const _default: CommandFactory<{}, {
+    schema: string;
+    documents: string;
+    deprecated: boolean;
+    noStrictFragments: boolean;
+    apollo: boolean;
+    keepClientFields: boolean;
+    maxDepth?: number | undefined;
+    filter?: string[] | undefined;
+    onlyErrors?: boolean | undefined;
+    relativePaths?: boolean | undefined;
+    output?: string | undefined;
+    silent?: boolean | undefined;
+    ignore?: string[] | undefined;
+} & GlobalArgs>;
+export default _default;

package/index.js

@@ -0,0 +1,238 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+const tslib = require('tslib');
+const commands = require('@graphql-inspector/commands');
+const logger = require('@graphql-inspector/logger');
+const core = require('@graphql-inspector/core');
+const path = require('path');
+const fs = require('fs');
+const graphql = require('graphql');
+
+function handler({ schema, documents, strictFragments, maxDepth, apollo, keepClientFields, failOnDeprecated, filter, onlyErrors, relativePaths, output, silent, }) {
+    let invalidDocuments = core.validate(schema, documents.map((doc) => new graphql.Source(graphql.print(doc.document), doc.location)), {
+        strictFragments,
+        maxDepth,
+        apollo,
+        keepClientFields,
+    });
+    if (!invalidDocuments.length) {
+        logger.Logger.success('All documents are valid');
+    }
+    else {
+        if (failOnDeprecated) {
+            invalidDocuments = moveDeprecatedToErrors(invalidDocuments);
+        }
+        if (relativePaths) {
+            invalidDocuments = useRelativePaths(invalidDocuments);
+        }
+        const errorsCount = countErrors(invalidDocuments);
+        const deprecated = countDeprecated(invalidDocuments);
+        const shouldFailProcess = errorsCount > 0;
+        if (errorsCount) {
+            if (!silent) {
+                logger.Logger.log(`\nDetected ${errorsCount} invalid document${errorsCount > 1 ? 's' : ''}:\n`);
+            }
+            printInvalidDocuments(useFilter(invalidDocuments, filter), 'errors', true, silent);
+        }
+        else {
+            logger.Logger.success('All documents are valid');
+        }
+        if (deprecated && !onlyErrors) {
+            if (!silent) {
+                logger.Logger.info(`\nDetected ${deprecated} document${deprecated > 1 ? 's' : ''} with deprecated fields:\n`);
+            }
+            printInvalidDocuments(useFilter(invalidDocuments, filter), 'deprecated', false, silent);
+        }
+        if (output) {
+            fs.writeFileSync(output, JSON.stringify({
+                status: !shouldFailProcess,
+                documents: useFilter(invalidDocuments, filter),
+            }, null, 2), {
+                encoding: 'utf-8',
+            });
+        }
+        if (shouldFailProcess) {
+            process.exit(1);
+        }
+    }
+}
+function moveDeprecatedToErrors(docs) {
+    return docs.map((doc) => {
+        var _a, _b;
+        return ({
+            source: doc.source,
+            errors: [...((_a = doc.errors) !== null && _a !== void 0 ? _a : []), ...((_b = doc.deprecated) !== null && _b !== void 0 ? _b : [])],
+            deprecated: [],
+        });
+    });
+}
+function useRelativePaths(docs) {
+    return docs.map((doc) => {
+        doc.source.name = path.relative(process.cwd(), doc.source.name);
+        return doc;
+    });
+}
+function useFilter(docs, patterns) {
+    if (!patterns || !patterns.length) {
+        return docs;
+    }
+    return docs.filter((doc) => patterns.some((filepath) => doc.source.name.includes(filepath)));
+}
+const index = commands.createCommand((api) => {
+    const { loaders } = api;
+    return {
+        command: 'validate <documents> <schema>',
+        describe: 'Validate Fragments and Operations',
+        builder(yargs) {
+            return yargs
+                .positional('schema', {
+                describe: 'Point to a schema',
+                type: 'string',
+                demandOption: true,
+            })
+                .positional('documents', {
+                describe: 'Point to documents',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                deprecated: {
+                    alias: 'd',
+                    describe: 'Fail on deprecated usage',
+                    type: 'boolean',
+                    default: false,
+                },
+                noStrictFragments: {
+                    describe: 'Do not fail on duplicated fragment names',
+                    type: 'boolean',
+                    default: false,
+                },
+                maxDepth: {
+                    describe: 'Fail on deep operations',
+                    type: 'number',
+                },
+                apollo: {
+                    describe: 'Support Apollo directives',
+                    type: 'boolean',
+                    default: false,
+                },
+                keepClientFields: {
+                    describe: 'Keeps the fields with @client, but removes @client directive from them',
+                    type: 'boolean',
+                    default: false,
+                },
+                filter: {
+                    describe: 'Show results only from a list of files (or file)',
+                    array: true,
+                    type: 'string',
+                },
+                ignore: {
+                    describe: 'Ignore and do not load these files (supports glob)',
+                    array: true,
+                    type: 'string',
+                },
+                onlyErrors: {
+                    describe: 'Show only errors',
+                    type: 'boolean',
+                    default: false,
+                },
+                relativePaths: {
+                    describe: 'Show relative paths',
+                    type: 'boolean',
+                    default: false,
+                },
+                silent: {
+                    describe: 'Do not print results',
+                    type: 'boolean',
+                    default: false,
+                },
+                output: {
+                    describe: 'Output JSON file',
+                    type: 'string',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                const { headers, token } = commands.parseGlobalArgs(args);
+                const apollo = args.apollo || false;
+                const aws = args.aws || false;
+                const apolloFederation = args.federation || false;
+                const method = ((_a = args.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'POST';
+                const maxDepth = args.maxDepth || undefined;
+                const strictFragments = !args.noStrictFragments;
+                const keepClientFields = args.keepClientFields || false;
+                const failOnDeprecated = args.deprecated;
+                const output = args.output;
+                const silent = args.silent || false;
+                const relativePaths = args.relativePaths || false;
+                const onlyErrors = args.onlyErrors || false;
+                const ignore = args.ignore || [];
+                const schema = yield loaders.loadSchema(args.schema, {
+                    headers,
+                    token,
+                    method,
+                }, apolloFederation, aws);
+                const documents = yield loaders.loadDocuments(args.documents, {
+                    ignore,
+                });
+                return handler({
+                    schema,
+                    documents,
+                    apollo,
+                    maxDepth,
+                    strictFragments,
+                    keepClientFields,
+                    failOnDeprecated,
+                    filter: args.filter,
+                    silent,
+                    output,
+                    relativePaths,
+                    onlyErrors,
+                });
+            });
+        },
+    };
+});
+function countErrors(invalidDocuments) {
+    if (invalidDocuments.length) {
+        return invalidDocuments.filter((doc) => doc.errors && doc.errors.length)
+            .length;
+    }
+    return 0;
+}
+function countDeprecated(invalidDocuments) {
+    if (invalidDocuments.length) {
+        return invalidDocuments.filter((doc) => doc.deprecated && doc.deprecated.length).length;
+    }
+    return 0;
+}
+function printInvalidDocuments(invalidDocuments, listKey, isError = false, silent = false) {
+    if (silent) {
+        return;
+    }
+    invalidDocuments.forEach((doc) => {
+        if (doc.errors.length) {
+            renderErrors(doc.source.name, doc[listKey], isError).forEach((line) => {
+                logger.Logger.log(line);
+            });
+        }
+    });
+}
+function renderErrors(sourceName, errors, isError = false) {
+    const errorsAsString = errors
+        .map((e) => ` - ${logger.bolderize(e.message)}`)
+        .join('\n');
+    return [
+        isError ? logger.chalk.redBright('error') : logger.chalk.yellowBright('warn'),
+        `in ${sourceName}:\n\n`,
+        errorsAsString,
+        '\n\n',
+    ];
+}
+
+exports.default = index;
+exports.handler = handler;

package/index.mjs

@@ -0,0 +1,234 @@
+import { __awaiter } from 'tslib';
+import { createCommand, parseGlobalArgs } from '@graphql-inspector/commands';
+import { Logger, chalk, bolderize } from '@graphql-inspector/logger';
+import { validate } from '@graphql-inspector/core';
+import { relative } from 'path';
+import { writeFileSync } from 'fs';
+import { Source, print } from 'graphql';
+
+function handler({ schema, documents, strictFragments, maxDepth, apollo, keepClientFields, failOnDeprecated, filter, onlyErrors, relativePaths, output, silent, }) {
+    let invalidDocuments = validate(schema, documents.map((doc) => new Source(print(doc.document), doc.location)), {
+        strictFragments,
+        maxDepth,
+        apollo,
+        keepClientFields,
+    });
+    if (!invalidDocuments.length) {
+        Logger.success('All documents are valid');
+    }
+    else {
+        if (failOnDeprecated) {
+            invalidDocuments = moveDeprecatedToErrors(invalidDocuments);
+        }
+        if (relativePaths) {
+            invalidDocuments = useRelativePaths(invalidDocuments);
+        }
+        const errorsCount = countErrors(invalidDocuments);
+        const deprecated = countDeprecated(invalidDocuments);
+        const shouldFailProcess = errorsCount > 0;
+        if (errorsCount) {
+            if (!silent) {
+                Logger.log(`\nDetected ${errorsCount} invalid document${errorsCount > 1 ? 's' : ''}:\n`);
+            }
+            printInvalidDocuments(useFilter(invalidDocuments, filter), 'errors', true, silent);
+        }
+        else {
+            Logger.success('All documents are valid');
+        }
+        if (deprecated && !onlyErrors) {
+            if (!silent) {
+                Logger.info(`\nDetected ${deprecated} document${deprecated > 1 ? 's' : ''} with deprecated fields:\n`);
+            }
+            printInvalidDocuments(useFilter(invalidDocuments, filter), 'deprecated', false, silent);
+        }
+        if (output) {
+            writeFileSync(output, JSON.stringify({
+                status: !shouldFailProcess,
+                documents: useFilter(invalidDocuments, filter),
+            }, null, 2), {
+                encoding: 'utf-8',
+            });
+        }
+        if (shouldFailProcess) {
+            process.exit(1);
+        }
+    }
+}
+function moveDeprecatedToErrors(docs) {
+    return docs.map((doc) => {
+        var _a, _b;
+        return ({
+            source: doc.source,
+            errors: [...((_a = doc.errors) !== null && _a !== void 0 ? _a : []), ...((_b = doc.deprecated) !== null && _b !== void 0 ? _b : [])],
+            deprecated: [],
+        });
+    });
+}
+function useRelativePaths(docs) {
+    return docs.map((doc) => {
+        doc.source.name = relative(process.cwd(), doc.source.name);
+        return doc;
+    });
+}
+function useFilter(docs, patterns) {
+    if (!patterns || !patterns.length) {
+        return docs;
+    }
+    return docs.filter((doc) => patterns.some((filepath) => doc.source.name.includes(filepath)));
+}
+const index = createCommand((api) => {
+    const { loaders } = api;
+    return {
+        command: 'validate <documents> <schema>',
+        describe: 'Validate Fragments and Operations',
+        builder(yargs) {
+            return yargs
+                .positional('schema', {
+                describe: 'Point to a schema',
+                type: 'string',
+                demandOption: true,
+            })
+                .positional('documents', {
+                describe: 'Point to documents',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                deprecated: {
+                    alias: 'd',
+                    describe: 'Fail on deprecated usage',
+                    type: 'boolean',
+                    default: false,
+                },
+                noStrictFragments: {
+                    describe: 'Do not fail on duplicated fragment names',
+                    type: 'boolean',
+                    default: false,
+                },
+                maxDepth: {
+                    describe: 'Fail on deep operations',
+                    type: 'number',
+                },
+                apollo: {
+                    describe: 'Support Apollo directives',
+                    type: 'boolean',
+                    default: false,
+                },
+                keepClientFields: {
+                    describe: 'Keeps the fields with @client, but removes @client directive from them',
+                    type: 'boolean',
+                    default: false,
+                },
+                filter: {
+                    describe: 'Show results only from a list of files (or file)',
+                    array: true,
+                    type: 'string',
+                },
+                ignore: {
+                    describe: 'Ignore and do not load these files (supports glob)',
+                    array: true,
+                    type: 'string',
+                },
+                onlyErrors: {
+                    describe: 'Show only errors',
+                    type: 'boolean',
+                    default: false,
+                },
+                relativePaths: {
+                    describe: 'Show relative paths',
+                    type: 'boolean',
+                    default: false,
+                },
+                silent: {
+                    describe: 'Do not print results',
+                    type: 'boolean',
+                    default: false,
+                },
+                output: {
+                    describe: 'Output JSON file',
+                    type: 'string',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const { headers, token } = parseGlobalArgs(args);
+                const apollo = args.apollo || false;
+                const aws = args.aws || false;
+                const apolloFederation = args.federation || false;
+                const method = ((_a = args.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'POST';
+                const maxDepth = args.maxDepth || undefined;
+                const strictFragments = !args.noStrictFragments;
+                const keepClientFields = args.keepClientFields || false;
+                const failOnDeprecated = args.deprecated;
+                const output = args.output;
+                const silent = args.silent || false;
+                const relativePaths = args.relativePaths || false;
+                const onlyErrors = args.onlyErrors || false;
+                const ignore = args.ignore || [];
+                const schema = yield loaders.loadSchema(args.schema, {
+                    headers,
+                    token,
+                    method,
+                }, apolloFederation, aws);
+                const documents = yield loaders.loadDocuments(args.documents, {
+                    ignore,
+                });
+                return handler({
+                    schema,
+                    documents,
+                    apollo,
+                    maxDepth,
+                    strictFragments,
+                    keepClientFields,
+                    failOnDeprecated,
+                    filter: args.filter,
+                    silent,
+                    output,
+                    relativePaths,
+                    onlyErrors,
+                });
+            });
+        },
+    };
+});
+function countErrors(invalidDocuments) {
+    if (invalidDocuments.length) {
+        return invalidDocuments.filter((doc) => doc.errors && doc.errors.length)
+            .length;
+    }
+    return 0;
+}
+function countDeprecated(invalidDocuments) {
+    if (invalidDocuments.length) {
+        return invalidDocuments.filter((doc) => doc.deprecated && doc.deprecated.length).length;
+    }
+    return 0;
+}
+function printInvalidDocuments(invalidDocuments, listKey, isError = false, silent = false) {
+    if (silent) {
+        return;
+    }
+    invalidDocuments.forEach((doc) => {
+        if (doc.errors.length) {
+            renderErrors(doc.source.name, doc[listKey], isError).forEach((line) => {
+                Logger.log(line);
+            });
+        }
+    });
+}
+function renderErrors(sourceName, errors, isError = false) {
+    const errorsAsString = errors
+        .map((e) => ` - ${bolderize(e.message)}`)
+        .join('\n');
+    return [
+        isError ? chalk.redBright('error') : chalk.yellowBright('warn'),
+        `in ${sourceName}:\n\n`,
+        errorsAsString,
+        '\n\n',
+    ];
+}
+
+export default index;
+export { handler };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@graphql-inspector/validate-command",
+  "version": "0.0.0-PLACEHOLDER",
+  "description": "Validate Documents in GraphQL Inspector",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-inspector/commands": "0.0.0-PLACEHOLDER",
+    "@graphql-inspector/core": "0.0.0-PLACEHOLDER",
+    "@graphql-inspector/logger": "0.0.0-PLACEHOLDER",
+    "tslib": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "kamilkisiela/graphql-inspector",
+    "directory": "packages/commands/validate"
+  },
+  "keywords": [
+    "graphql",
+    "graphql-inspector",
+    "graphql-inspector-command",
+    "tools"
+  ],
+  "author": {
+    "name": "Kamil Kisiela",
+    "email": "kamil.kisiela@gmail.com",
+    "url": "https://github.com/kamilkisiela"
+  },
+  "license": "MIT",
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
+  },
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    }
+  }
+}