@graphql-inspector/audit-command 0.0.0-canary.36b26d2

package/index.d.ts

@@ -0,0 +1,16 @@
+import { GlobalArgs } from '@graphql-inspector/commands';
+import type { CalculateOperationComplexityConfig } from '@graphql-inspector/core';
+import { Source as DocumentSource } from '@graphql-tools/utils';
+declare const _default: import("@graphql-inspector/commands").CommandFactory<{}, {
+    documents: string;
+    detail: boolean;
+    complexityScalarCost: number;
+    complexityObjectCost: number;
+    complexityDepthCostFactor: number;
+} & GlobalArgs>;
+export default _default;
+export declare function handler(args: {
+    documents: DocumentSource[];
+    detail: boolean;
+    complexityConfig: CalculateOperationComplexityConfig;
+}): void;

package/index.js

@@ -0,0 +1,113 @@
+'use strict';
+
+Object.defineProperty(exports, '__esModule', { value: true });
+
+function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
+
+const tslib = require('tslib');
+const commands = require('@graphql-inspector/commands');
+const core = require('@graphql-inspector/core');
+const logger = require('@graphql-inspector/logger');
+const Table = _interopDefault(require('cli-table3'));
+
+const index = commands.createCommand(api => {
+    return {
+        command: 'audit <documents>',
+        describe: 'Audit Fragments and Operations for a better understanding of the depth, alias count, and directive count.',
+        builder(yargs) {
+            return yargs
+                .positional('documents', {
+                describe: 'Point to some documents',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                detail: {
+                    alias: 'd',
+                    describe: 'Print an overview of all operations and their audit breakdown.',
+                    type: 'boolean',
+                    default: false,
+                },
+                complexityScalarCost: {
+                    describe: 'The cost per scalar for calculating the complexity score.',
+                    type: 'number',
+                    default: 1,
+                },
+                complexityObjectCost: {
+                    describe: 'The cost per object for calculating the complexity score.',
+                    type: 'number',
+                    default: 2,
+                },
+                complexityDepthCostFactor: {
+                    describe: 'The cost factor per introduced depth level for calculating the complexity score.',
+                    type: 'number',
+                    default: 1.5,
+                },
+            });
+        },
+        handler(args) {
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                const { loaders } = api;
+                const ignore = args.ignore || [];
+                const documents = yield loaders.loadDocuments(args.documents, {
+                    ignore,
+                });
+                const complexityConfig = {
+                    scalarCost: args.complexityScalarCost,
+                    objectCost: args.complexityObjectCost,
+                    depthCostFactor: args.complexityDepthCostFactor,
+                };
+                return handler({ documents, detail: args.detail, complexityConfig });
+            });
+        },
+    };
+});
+function handler(args) {
+    const fragments = new Map();
+    const operations = new Map();
+    const getFragmentReference = (fragmentName) => fragments.get(fragmentName);
+    for (const record of args.documents) {
+        if (record.document) {
+            for (const definition of record.document.definitions) {
+                if (definition.kind === 'FragmentDefinition') {
+                    fragments.set(definition.name.value, definition);
+                }
+                else if (definition.kind === 'OperationDefinition') {
+                    if (definition.name) {
+                        operations.set(definition.name.value, definition);
+                    }
+                }
+            }
+        }
+    }
+    let maxDepth = 0;
+    let maxAliases = 0;
+    let maxDirectives = 0;
+    let maxComplexity = 0;
+    const results = [];
+    for (const [name, operation] of operations.entries()) {
+        const depth = core.countDepth(operation, 0, getFragmentReference);
+        const aliases = core.countAliases(operation, getFragmentReference);
+        const directives = core.countDirectives(operation, getFragmentReference);
+        const complexity = core.calculateOperationComplexity(operation, args.complexityConfig, getFragmentReference);
+        results.push([name, depth, aliases, directives, complexity]);
+        maxDepth = Math.max(maxDepth, depth);
+        maxAliases = Math.max(maxAliases, aliases);
+        maxDirectives = Math.max(maxDirectives, directives);
+        maxComplexity = Math.max(maxComplexity, complexity);
+    }
+    if (args.detail) {
+        const table = new Table({
+            head: ['Operation Name', 'Depth', 'Aliases', 'Directives', 'Complexity Score'],
+        });
+        table.push(...results);
+        logger.Logger.log(table.toString());
+    }
+    logger.Logger.log(`Maximum depth is ${logger.chalk.bold(maxDepth)}`);
+    logger.Logger.log(`Maximum alias amount is ${logger.chalk.bold(maxAliases)}`);
+    logger.Logger.log(`Maximum directive amount is ${logger.chalk.bold(maxDirectives)}`);
+    logger.Logger.log(`Maximum complexity score is ${logger.chalk.bold(maxComplexity)}`);
+}
+
+exports.default = index;
+exports.handler = handler;

package/index.mjs

@@ -0,0 +1,107 @@
+import { __awaiter } from 'tslib';
+import { createCommand } from '@graphql-inspector/commands';
+import { countDepth, countAliases, countDirectives, calculateOperationComplexity } from '@graphql-inspector/core';
+import { Logger, chalk } from '@graphql-inspector/logger';
+import Table from 'cli-table3';
+
+const index = createCommand(api => {
+    return {
+        command: 'audit <documents>',
+        describe: 'Audit Fragments and Operations for a better understanding of the depth, alias count, and directive count.',
+        builder(yargs) {
+            return yargs
+                .positional('documents', {
+                describe: 'Point to some documents',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                detail: {
+                    alias: 'd',
+                    describe: 'Print an overview of all operations and their audit breakdown.',
+                    type: 'boolean',
+                    default: false,
+                },
+                complexityScalarCost: {
+                    describe: 'The cost per scalar for calculating the complexity score.',
+                    type: 'number',
+                    default: 1,
+                },
+                complexityObjectCost: {
+                    describe: 'The cost per object for calculating the complexity score.',
+                    type: 'number',
+                    default: 2,
+                },
+                complexityDepthCostFactor: {
+                    describe: 'The cost factor per introduced depth level for calculating the complexity score.',
+                    type: 'number',
+                    default: 1.5,
+                },
+            });
+        },
+        handler(args) {
+            return __awaiter(this, void 0, void 0, function* () {
+                const { loaders } = api;
+                const ignore = args.ignore || [];
+                const documents = yield loaders.loadDocuments(args.documents, {
+                    ignore,
+                });
+                const complexityConfig = {
+                    scalarCost: args.complexityScalarCost,
+                    objectCost: args.complexityObjectCost,
+                    depthCostFactor: args.complexityDepthCostFactor,
+                };
+                return handler({ documents, detail: args.detail, complexityConfig });
+            });
+        },
+    };
+});
+function handler(args) {
+    const fragments = new Map();
+    const operations = new Map();
+    const getFragmentReference = (fragmentName) => fragments.get(fragmentName);
+    for (const record of args.documents) {
+        if (record.document) {
+            for (const definition of record.document.definitions) {
+                if (definition.kind === 'FragmentDefinition') {
+                    fragments.set(definition.name.value, definition);
+                }
+                else if (definition.kind === 'OperationDefinition') {
+                    if (definition.name) {
+                        operations.set(definition.name.value, definition);
+                    }
+                }
+            }
+        }
+    }
+    let maxDepth = 0;
+    let maxAliases = 0;
+    let maxDirectives = 0;
+    let maxComplexity = 0;
+    const results = [];
+    for (const [name, operation] of operations.entries()) {
+        const depth = countDepth(operation, 0, getFragmentReference);
+        const aliases = countAliases(operation, getFragmentReference);
+        const directives = countDirectives(operation, getFragmentReference);
+        const complexity = calculateOperationComplexity(operation, args.complexityConfig, getFragmentReference);
+        results.push([name, depth, aliases, directives, complexity]);
+        maxDepth = Math.max(maxDepth, depth);
+        maxAliases = Math.max(maxAliases, aliases);
+        maxDirectives = Math.max(maxDirectives, directives);
+        maxComplexity = Math.max(maxComplexity, complexity);
+    }
+    if (args.detail) {
+        const table = new Table({
+            head: ['Operation Name', 'Depth', 'Aliases', 'Directives', 'Complexity Score'],
+        });
+        table.push(...results);
+        Logger.log(table.toString());
+    }
+    Logger.log(`Maximum depth is ${chalk.bold(maxDepth)}`);
+    Logger.log(`Maximum alias amount is ${chalk.bold(maxAliases)}`);
+    Logger.log(`Maximum directive amount is ${chalk.bold(maxDirectives)}`);
+    Logger.log(`Maximum complexity score is ${chalk.bold(maxComplexity)}`);
+}
+
+export default index;
+export { handler };

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@graphql-inspector/audit-command",
+  "version": "0.0.0-canary.36b26d2",
+  "description": "Audit 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-canary.36b26d2",
+    "@graphql-inspector/core": "0.0.0-canary.36b26d2",
+    "@graphql-inspector/logger": "0.0.0-canary.36b26d2",
+    "cli-table3": "0.6.2",
+    "tslib": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "kamilkisiela/graphql-inspector",
+    "directory": "packages/commands/audit"
+  },
+  "keywords": [
+    "graphql",
+    "graphql-inspector",
+    "graphql-inspector-command",
+    "tools"
+  ],
+  "author": {
+    "name": "Laurin Quast",
+    "email": "laurinquast@googlemail.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"
+    }
+  }
+}