@graphql-inspector/similar-command 0.0.0-PLACEHOLDER

package/index.d.ts

@@ -0,0 +1,16 @@
+import { GlobalArgs, CommandFactory } from '@graphql-inspector/commands';
+import { GraphQLSchema } from 'graphql';
+export { CommandFactory };
+export declare function handler({ schema, writePath, type, threshold, }: {
+    schema: GraphQLSchema;
+    writePath?: string;
+    type?: string;
+    threshold?: number;
+}): void;
+declare const _default: CommandFactory<{}, {
+    schema: string;
+    name?: string | undefined;
+    threshold?: number | undefined;
+    write?: string | undefined;
+} & GlobalArgs>;
+export default _default;

package/index.js

@@ -0,0 +1,151 @@
+'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');
+
+function handler({ schema, writePath, type, threshold, }) {
+    const shouldWrite = typeof writePath !== 'undefined';
+    const similarMap = core.similar(schema, type, threshold);
+    if (!Object.keys(similarMap).length) {
+        logger.Logger.info('No similar types found');
+    }
+    else {
+        for (const typeName in similarMap) {
+            if (similarMap.hasOwnProperty(typeName)) {
+                const matches = similarMap[typeName];
+                const prefix = core.getTypePrefix(schema.getType(typeName));
+                const sourceType = logger.chalk.bold(typeName);
+                const name = matches.bestMatch.target.typeId;
+                logger.Logger.log('');
+                logger.Logger.log(`${prefix} ${sourceType}`);
+                logger.Logger.log(printResult(name, matches.bestMatch.rating));
+                matches.ratings.forEach((match) => {
+                    logger.Logger.log(printResult(match.target.typeId, match.rating));
+                });
+            }
+        }
+        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;
+            const results = transformMap(similarMap);
+            if (ext === 'json') {
+                output = outputJSON(results);
+            }
+            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: 'similar <schema>',
+        describe: 'Find similar types in a schema',
+        builder(yargs) {
+            return yargs
+                .positional('schema', {
+                describe: 'Point to a schema',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                n: {
+                    alias: 'name',
+                    describe: 'Name of a type',
+                    type: 'string',
+                },
+                t: {
+                    alias: 'threshold',
+                    describe: 'Threshold of similarity ratio',
+                    type: 'number',
+                },
+                w: {
+                    alias: 'write',
+                    describe: 'Write a file with stats',
+                    type: 'string',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return tslib.__awaiter(this, void 0, void 0, function* () {
+                const { headers, token } = commands.parseGlobalArgs(args);
+                const writePath = args.write;
+                const type = args.name;
+                const threshold = args.threshold;
+                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, {
+                    headers,
+                    token,
+                    method,
+                }, apolloFederation, aws);
+                return handler({ schema, writePath, type, threshold });
+            });
+        },
+    };
+});
+function indent(line, space) {
+    return line.padStart(line.length + space, ' ');
+}
+function transformMap(similarMap) {
+    const results = {};
+    for (const typename in similarMap) {
+        if (similarMap.hasOwnProperty(typename)) {
+            const result = similarMap[typename];
+            results[typename] = [];
+            if (result.bestMatch) {
+                results[typename].push(trasformResult(result.bestMatch));
+            }
+            if (result.ratings) {
+                results[typename].push(...result.ratings.map(trasformResult));
+            }
+        }
+    }
+    return results;
+}
+function trasformResult(record) {
+    return {
+        typename: record.target.typeId,
+        rating: record.rating,
+    };
+}
+function outputJSON(results) {
+    return JSON.stringify(results);
+}
+function printResult(name, rating) {
+    const percentage = logger.chalk.grey(`(${formatRating(rating)}%)`);
+    return indent(`${printScale(rating)} ${percentage} ${name}`, 0);
+}
+function printScale(ratio) {
+    const percentage = Math.floor(ratio * 100);
+    const levels = [0, 30, 50, 70, 90];
+    return levels
+        .map((level) => percentage >= level)
+        .map((enabled) => (enabled ? logger.figures.bullet : logger.chalk.gray(logger.figures.bullet)))
+        .join('');
+}
+function formatRating(ratio) {
+    return Math.floor(ratio * 100);
+}
+
+exports.default = index;
+exports.handler = handler;

package/index.mjs

@@ -0,0 +1,147 @@
+import { __awaiter } from 'tslib';
+import { createCommand, parseGlobalArgs, ensureAbsolute } from '@graphql-inspector/commands';
+import { Logger, chalk, figures } from '@graphql-inspector/logger';
+import { similar, getTypePrefix } from '@graphql-inspector/core';
+import { extname } from 'path';
+import { writeFileSync } from 'fs';
+
+function handler({ schema, writePath, type, threshold, }) {
+    const shouldWrite = typeof writePath !== 'undefined';
+    const similarMap = similar(schema, type, threshold);
+    if (!Object.keys(similarMap).length) {
+        Logger.info('No similar types found');
+    }
+    else {
+        for (const typeName in similarMap) {
+            if (similarMap.hasOwnProperty(typeName)) {
+                const matches = similarMap[typeName];
+                const prefix = getTypePrefix(schema.getType(typeName));
+                const sourceType = chalk.bold(typeName);
+                const name = matches.bestMatch.target.typeId;
+                Logger.log('');
+                Logger.log(`${prefix} ${sourceType}`);
+                Logger.log(printResult(name, matches.bestMatch.rating));
+                matches.ratings.forEach((match) => {
+                    Logger.log(printResult(match.target.typeId, match.rating));
+                });
+            }
+        }
+        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;
+            const results = transformMap(similarMap);
+            if (ext === 'json') {
+                output = outputJSON(results);
+            }
+            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: 'similar <schema>',
+        describe: 'Find similar types in a schema',
+        builder(yargs) {
+            return yargs
+                .positional('schema', {
+                describe: 'Point to a schema',
+                type: 'string',
+                demandOption: true,
+            })
+                .options({
+                n: {
+                    alias: 'name',
+                    describe: 'Name of a type',
+                    type: 'string',
+                },
+                t: {
+                    alias: 'threshold',
+                    describe: 'Threshold of similarity ratio',
+                    type: 'number',
+                },
+                w: {
+                    alias: 'write',
+                    describe: 'Write a file with stats',
+                    type: 'string',
+                },
+            });
+        },
+        handler(args) {
+            var _a;
+            return __awaiter(this, void 0, void 0, function* () {
+                const { headers, token } = parseGlobalArgs(args);
+                const writePath = args.write;
+                const type = args.name;
+                const threshold = args.threshold;
+                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, {
+                    headers,
+                    token,
+                    method,
+                }, apolloFederation, aws);
+                return handler({ schema, writePath, type, threshold });
+            });
+        },
+    };
+});
+function indent(line, space) {
+    return line.padStart(line.length + space, ' ');
+}
+function transformMap(similarMap) {
+    const results = {};
+    for (const typename in similarMap) {
+        if (similarMap.hasOwnProperty(typename)) {
+            const result = similarMap[typename];
+            results[typename] = [];
+            if (result.bestMatch) {
+                results[typename].push(trasformResult(result.bestMatch));
+            }
+            if (result.ratings) {
+                results[typename].push(...result.ratings.map(trasformResult));
+            }
+        }
+    }
+    return results;
+}
+function trasformResult(record) {
+    return {
+        typename: record.target.typeId,
+        rating: record.rating,
+    };
+}
+function outputJSON(results) {
+    return JSON.stringify(results);
+}
+function printResult(name, rating) {
+    const percentage = chalk.grey(`(${formatRating(rating)}%)`);
+    return indent(`${printScale(rating)} ${percentage} ${name}`, 0);
+}
+function printScale(ratio) {
+    const percentage = Math.floor(ratio * 100);
+    const levels = [0, 30, 50, 70, 90];
+    return levels
+        .map((level) => percentage >= level)
+        .map((enabled) => (enabled ? figures.bullet : chalk.gray(figures.bullet)))
+        .join('');
+}
+function formatRating(ratio) {
+    return Math.floor(ratio * 100);
+}
+
+export default index;
+export { handler };

package/package.json

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