@graphql-inspector/coverage-command 0.0.0-PLACEHOLDER

package/index.d.ts

@@ -0,0 +1,17 @@
+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, silent, writePath, }: {
+    schema: GraphQLSchema;
+    documents: DocumentSource[];
+    silent?: boolean;
+    writePath?: string;
+}): void;
+declare const _default: CommandFactory<{}, {
+    schema: string;
+    documents: string;
+    write?: string | undefined;
+    silent?: boolean | undefined;
+} & GlobalArgs>;
+export default _default;

package/index.js

@@ -0,0 +1,129 @@
+'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 graphql = require('graphql');
+const path = require('path');
+const fs = require('fs');
+
+function handler({ schema, documents, silent, writePath, }) {
+    const shouldWrite = typeof writePath !== 'undefined';
+    const coverage = core.coverage(schema, documents.map((doc) => new graphql.Source(graphql.print(doc.document), doc.location)));
+    if (silent !== true) {
+        renderCoverage(coverage);
+    }
+    if (shouldWrite) {
+        if (typeof writePath !== 'string') {
+            throw new Error(`--write is not valid file path: ${writePath}`);
+        }
+        const absPath = commands.ensureAbsolute(writePath);
+        const ext = path.extname(absPath).replace('.', '').toLocaleLowerCase();
+        let output = undefined;
+        if (ext === 'json') {
+            output = outputJSON(coverage);
+        }
+        if (output) {
+            fs.writeFileSync(absPath, output, {
+                encoding: 'utf-8',
+            });
+            logger.Logger.success(`Available at ${absPath}\n`);
+        }
+        else {
+            throw new Error(`Extension ${ext} is not supported`);
+        }
+    }
+}
+const index = commands.createCommand((api) => {
+    const { loaders } = api;
+    return {
+        command: 'coverage <documents> <schema>',
+        describe: 'Schema coverage based on documents',
+        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({
+                w: {
+                    alias: 'write',
+                    describe: 'Write a file with coverage stats',
+                    type: 'string',
+                },
+                s: {
+                    alias: 'silent',
+                    describe: 'Do not render any stats in the terminal',
+                    type: 'boolean',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                const writePath = args.write;
+                const silent = args.silent;
+                const { headers, token } = commands.parseGlobalArgs(args);
+                const apolloFederation = args.federation || false;
+                const aws = args.aws || false;
+                const method = ((_a = args.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'POST';
+                const schema = yield loaders.loadSchema(args.schema, {
+                    token,
+                    headers,
+                    method,
+                }, apolloFederation, aws);
+                const documents = yield loaders.loadDocuments(args.documents);
+                return handler({ schema, documents, silent, writePath });
+            });
+        },
+    };
+});
+function outputJSON(coverage) {
+    return JSON.stringify(coverage, null, 2);
+}
+function renderCoverage(coverage) {
+    logger.Logger.info('Schema coverage based on documents:\n');
+    for (const typeName in coverage.types) {
+        if (coverage.types.hasOwnProperty(typeName)) {
+            const typeCoverage = coverage.types[typeName];
+            logger.Logger.log([
+                logger.chalk.grey(core.getTypePrefix(typeCoverage.type)),
+                logger.chalk.bold(`${typeName}`),
+                logger.chalk.grey('{'),
+            ].join(' '));
+            for (const childName in typeCoverage.children) {
+                if (typeCoverage.children.hasOwnProperty(childName)) {
+                    const childCoverage = typeCoverage.children[childName];
+                    if (childCoverage.hits) {
+                        logger.Logger.log([
+                            indent(childName, 2),
+                            logger.chalk.italic.grey(`x ${childCoverage.hits}`),
+                        ].join(' '));
+                    }
+                    else {
+                        logger.Logger.log([
+                            logger.chalk.redBright(indent(childName, 2)),
+                            logger.chalk.italic.grey('x 0'),
+                        ].join(' '));
+                    }
+                }
+            }
+            logger.Logger.log(logger.chalk.grey('}\n'));
+        }
+    }
+}
+function indent(line, space) {
+    return line.padStart(line.length + space, ' ');
+}
+
+exports.default = index;
+exports.handler = handler;

package/index.mjs

@@ -0,0 +1,125 @@
+import { __awaiter } from 'tslib';
+import { createCommand, parseGlobalArgs, ensureAbsolute } from '@graphql-inspector/commands';
+import { Logger, chalk } from '@graphql-inspector/logger';
+import { coverage, getTypePrefix } from '@graphql-inspector/core';
+import { Source, print } from 'graphql';
+import { extname } from 'path';
+import { writeFileSync } from 'fs';
+
+function handler({ schema, documents, silent, writePath, }) {
+    const shouldWrite = typeof writePath !== 'undefined';
+    const coverage$1 = coverage(schema, documents.map((doc) => new Source(print(doc.document), doc.location)));
+    if (silent !== true) {
+        renderCoverage(coverage$1);
+    }
+    if (shouldWrite) {
+        if (typeof writePath !== 'string') {
+            throw new Error(`--write is not valid file path: ${writePath}`);
+        }
+        const absPath = ensureAbsolute(writePath);
+        const ext = extname(absPath).replace('.', '').toLocaleLowerCase();
+        let output = undefined;
+        if (ext === 'json') {
+            output = outputJSON(coverage$1);
+        }
+        if (output) {
+            writeFileSync(absPath, output, {
+                encoding: 'utf-8',
+            });
+            Logger.success(`Available at ${absPath}\n`);
+        }
+        else {
+            throw new Error(`Extension ${ext} is not supported`);
+        }
+    }
+}
+const index = createCommand((api) => {
+    const { loaders } = api;
+    return {
+        command: 'coverage <documents> <schema>',
+        describe: 'Schema coverage based on documents',
+        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({
+                w: {
+                    alias: 'write',
+                    describe: 'Write a file with coverage stats',
+                    type: 'string',
+                },
+                s: {
+                    alias: 'silent',
+                    describe: 'Do not render any stats in the terminal',
+                    type: 'boolean',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const writePath = args.write;
+                const silent = args.silent;
+                const { headers, token } = parseGlobalArgs(args);
+                const apolloFederation = args.federation || false;
+                const aws = args.aws || false;
+                const method = ((_a = args.method) === null || _a === void 0 ? void 0 : _a.toUpperCase()) || 'POST';
+                const schema = yield loaders.loadSchema(args.schema, {
+                    token,
+                    headers,
+                    method,
+                }, apolloFederation, aws);
+                const documents = yield loaders.loadDocuments(args.documents);
+                return handler({ schema, documents, silent, writePath });
+            });
+        },
+    };
+});
+function outputJSON(coverage) {
+    return JSON.stringify(coverage, null, 2);
+}
+function renderCoverage(coverage) {
+    Logger.info('Schema coverage based on documents:\n');
+    for (const typeName in coverage.types) {
+        if (coverage.types.hasOwnProperty(typeName)) {
+            const typeCoverage = coverage.types[typeName];
+            Logger.log([
+                chalk.grey(getTypePrefix(typeCoverage.type)),
+                chalk.bold(`${typeName}`),
+                chalk.grey('{'),
+            ].join(' '));
+            for (const childName in typeCoverage.children) {
+                if (typeCoverage.children.hasOwnProperty(childName)) {
+                    const childCoverage = typeCoverage.children[childName];
+                    if (childCoverage.hits) {
+                        Logger.log([
+                            indent(childName, 2),
+                            chalk.italic.grey(`x ${childCoverage.hits}`),
+                        ].join(' '));
+                    }
+                    else {
+                        Logger.log([
+                            chalk.redBright(indent(childName, 2)),
+                            chalk.italic.grey('x 0'),
+                        ].join(' '));
+                    }
+                }
+            }
+            Logger.log(chalk.grey('}\n'));
+        }
+    }
+}
+function indent(line, space) {
+    return line.padStart(line.length + space, ' ');
+}
+
+export default index;
+export { handler };

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "@graphql-inspector/coverage-command",
+  "version": "0.0.0-PLACEHOLDER",
+  "description": "Schema Coverage 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/coverage"
+  },
+  "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"
+    }
+  }
+}