@graphql-inspector/cli 3.4.13-alpha-20230417141810-fd2d33e7 → 3.4.13

package/README.md

@@ -2,7 +2,7 @@
 
 [![npm version](https://badge.fury.io/js/%40graphql-inspector%2Fcli.svg)](https://npmjs.com/package/@graphql-inspector/cli)
 
-**GraphQL Inspector** ouputs a list of changes between two GraphQL schemas. Every change is
+**GraphQL Inspector** outputs a list of changes between two GraphQL schemas. Every change is
 precisely explained and marked as breaking, non-breaking or dangerous. It helps you validate
 documents and fragments against a schema and even find similar or duplicated types.
 
@@ -21,7 +21,7 @@ Major features:
 - **GitHub Bot**
 - **GitHub Actions**
 
-GraphQL Inspector has a **CLI** and also a **programatic API**, so you can use it however you want
+GraphQL Inspector has a **CLI** and also a **programmatic API**, so you can use it however you want
 to and even build tools on top of it.
 
 ## Installation
@@ -30,7 +30,7 @@ to and even build tools on top of it.
 # CLI
 pnpm add @graphql-inspector/cli
 
-# Core API for programatic usage
+# Core API for programmatic usage
 pnpm add @graphql-inspector/core
 ```
 

package/cjs/action/src/run.js

@@ -82,7 +82,7 @@ function run() {
             }
         }
         let [schemaRef, schemaPath] = schemaPointer.split(':');
-        if (useMerge && (pullRequest === null || pullRequest === void 0 ? void 0 : pullRequest.state) === 'open') {
+        if (useMerge && (pullRequest === null || pullRequest === void 0 ? void 0 : pullRequest.state) == 'open') {
             ref = `refs/pull/${pullRequest.number}/merge`;
             workspace = undefined;
             core.info(`EXPERIMENTAL - Using Pull Request ${ref}`);

package/cjs/commands/commands/src/index.js

@@ -26,26 +26,25 @@ function parseGlobalArgs(args) {
     const leftHeaders = {};
     const rightHeaders = {};
     if (args.header) {
-        for (const header of args.header) {
+        args.header.forEach(header => {
             const [name, ...values] = header.split(':');
             headers[name] = values.join('');
-        }
+        });
     }
     if (args.leftHeader) {
-        for (const leftHeader of args.leftHeader) {
+        args.leftHeader.forEach(leftHeader => {
             const [lname, ...lvalues] = leftHeader.split(':');
             leftHeaders[lname] = lvalues.join('');
-        }
+        });
     }
     if (args.rightHeader) {
-        for (const rightHeader of args.rightHeader) {
+        args.rightHeader.forEach(rightHeader => {
             const [rname, ...rvalues] = rightHeader.split(':');
             rightHeaders[rname] = rvalues.join('');
-        }
+        });
     }
     if (args.require) {
-        for (const mod of args.require)
-            require(mod);
+        args.require.forEach(mod => require(mod));
     }
     return { headers, leftHeaders, rightHeaders, token: args.token };
 }

package/cjs/commands/diff/src/index.js

@@ -133,23 +133,23 @@ function sortChanges(changes) {
 function reportBreakingChanges(changes) {
     const label = logger_1.symbols.error;
     const sorted = sortChanges(changes);
-    for (const change of sorted) {
+    sorted.forEach(change => {
         logger_1.Logger.log(`${label}  ${(0, logger_1.bolderize)(change.message)}`);
-    }
+    });
 }
 function reportDangerousChanges(changes) {
     const label = logger_1.symbols.warning;
     const sorted = sortChanges(changes);
-    for (const change of sorted) {
+    sorted.forEach(change => {
         logger_1.Logger.log(`${label}  ${(0, logger_1.bolderize)(change.message)}`);
-    }
+    });
 }
 function reportNonBreakingChanges(changes) {
     const label = logger_1.symbols.success;
     const sorted = sortChanges(changes);
-    for (const change of sorted) {
+    sorted.forEach(change => {
         logger_1.Logger.log(`${label}  ${(0, logger_1.bolderize)(change.message)}`);
-    }
+    });
 }
 function resolveRule(name) {
     const filepath = (0, commands_1.ensureAbsolute)(name);

package/cjs/commands/docs/src/index.js

@@ -8,9 +8,7 @@ exports.default = (0, commands_1.createCommand)(() => {
         command: ['docs', 'website'],
         describe: 'Open Documentation',
         handler() {
-            return tslib_1.__awaiter(this, void 0, void 0, function* () {
-                return yield (0, open_1.default)('https://graphql-inspector.com');
-            });
+            return (0, open_1.default)('https://graphql-inspector.com');
         },
     };
 });

package/cjs/commands/serve/src/fake.js

@@ -157,17 +157,17 @@ function assignResolveType(type) {
 }
 function forEachField(schema, fn) {
     const typeMap = schema.getTypeMap();
-    for (const typeName of Object.keys(typeMap)) {
+    Object.keys(typeMap).forEach(typeName => {
         const type = typeMap[typeName];
         // TODO: maybe have an option to include these?
         if (!(0, graphql_1.getNamedType)(type).name.startsWith('__') && type instanceof graphql_1.GraphQLObjectType) {
             const fields = type.getFields();
-            for (const fieldName of Object.keys(fields)) {
+            Object.keys(fields).forEach(fieldName => {
                 const field = fields[fieldName];
                 fn(field, typeName, fieldName);
-            }
+            });
         }
-    }
+    });
 }
 class MockList {
     // wrappedFunction can return another MockList or a value

package/cjs/commands/serve/src/index.js

@@ -1,11 +1,10 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const tslib_1 = require("tslib");
-const http_1 = require("http");
-const graphql_yoga_1 = require("graphql-yoga");
 const open_1 = tslib_1.__importDefault(require("open"));
 const commands_1 = require("@graphql-inspector/commands");
 const logger_1 = require("@graphql-inspector/logger");
+const node_1 = require("@graphql-yoga/node");
 const fake_js_1 = require("./fake.js");
 exports.default = (0, commands_1.createCommand)(api => {
     const { loaders } = api;
@@ -43,16 +42,18 @@ exports.default = (0, commands_1.createCommand)(api => {
                 const port = args.port;
                 try {
                     (0, fake_js_1.fake)(schema);
-                    const yoga = (0, graphql_yoga_1.createYoga)({ schema, cors: true, logging: false });
-                    const server = (0, http_1.createServer)(yoga);
-                    yield server.listen(port, () => {
-                        console.info(`Server is running on http://localhost:${port}`);
+                    const server = (0, node_1.createServer)({
+                        schema,
+                        port,
+                        cors: true,
+                        logging: false,
                     });
+                    yield server.start();
                     const url = `http://localhost:${port}`;
                     logger_1.Logger.success(`GraphQL API:    ${url}`);
                     yield (0, open_1.default)(url);
                     const shutdown = () => {
-                        server.close();
+                        server.stop();
                         process.exit(0);
                     };
                     process.on('SIGINT', shutdown);

package/cjs/commands/similar/src/index.js

@@ -23,9 +23,9 @@ function handler({ schema, writePath, type, threshold, }) {
             logger_1.Logger.log('');
             logger_1.Logger.log(`${prefix} ${sourceType}`);
             logger_1.Logger.log(printResult(name, matches.bestMatch.rating));
-            for (const match of matches.ratings) {
+            matches.ratings.forEach(match => {
                 logger_1.Logger.log(printResult(match.target.typeId, match.rating));
-            }
+            });
         }
     }
     if (shouldWrite) {

package/cjs/commands/validate/src/index.js

@@ -230,13 +230,13 @@ function printInvalidDocuments(invalidDocuments, listKey, isError = false, silen
     if (silent) {
         return;
     }
-    for (const doc of invalidDocuments) {
+    invalidDocuments.forEach(doc => {
         if (doc.errors.length) {
-            for (const line of renderErrors(doc.source.name, doc[listKey], isError)) {
+            renderErrors(doc.source.name, doc[listKey], isError).forEach(line => {
                 logger_1.Logger.log(line);
-            }
+            });
         }
-    }
+    });
 }
 function renderErrors(sourceName, errors, isError = false) {
     const errorsAsString = errors.map(e => ` - ${(0, logger_1.bolderize)(e.message)}`).join('\n');

package/cjs/core/src/ast/document.js

@@ -13,7 +13,7 @@ function readDocument(source) {
     const documentNode = (0, graphql_1.parse)(source.body);
     const filepath = source.name;
     const definitions = documentNode.definitions || [];
-    for (const node of definitions) {
+    definitions.forEach((node) => {
         if (isOperation(node)) {
             result.operations.push({
                 node,
@@ -26,7 +26,7 @@ function readDocument(source) {
                 source: filepath,
             });
         }
-    }
+    });
     result.hasFragments = result.fragments.length > 0;
     result.hasOperations = result.operations.length > 0;
     return result;

package/cjs/core/src/coverage/index.js

@@ -86,22 +86,22 @@ function coverage(schema, sources) {
         }
     }
     const documents = coverage.sources.map(document_js_1.readDocument);
-    for (const [i, doc] of documents.entries()) {
+    documents.forEach((doc, i) => {
         const source = coverage.sources[i];
-        for (const op of doc.operations) {
+        doc.operations.forEach(op => {
             (0, graphql_1.visit)(op.node, (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor(source)));
-        }
-        for (const fr of doc.fragments) {
+        });
+        doc.fragments.forEach(fr => {
             (0, graphql_1.visit)(fr.node, (0, graphql_1.visitWithTypeInfo)(typeInfo, visitor(source)));
-        }
-    }
+        });
+    });
     for (const key in coverage.types) {
         const me = coverage.types[key];
         processStats(me);
         coverage.stats.numTypes++;
         if (me.fieldsCountCovered > 0)
             coverage.stats.numTypesCovered++;
-        if (me.fieldsCount === me.fieldsCountCovered)
+        if (me.fieldsCount == me.fieldsCountCovered)
             coverage.stats.numTypesCoveredFully++;
         coverage.stats.numFields += me.fieldsCount;
         coverage.stats.numFiledsCovered += me.fieldsCountCovered;

package/cjs/core/src/diff/changes/argument.js

@@ -1,48 +1,109 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.fieldArgumentTypeChanged = exports.fieldArgumentDefaultChanged = exports.fieldArgumentDescriptionChanged = void 0;
+exports.fieldArgumentTypeChanged = exports.fieldArgumentTypeChangedFromMeta = exports.fieldArgumentDefaultChanged = exports.fieldArgumentDefaultChangedFromMeta = exports.fieldArgumentDescriptionChanged = exports.fieldArgumentDescriptionChangedFromMeta = void 0;
 const graphql_js_1 = require("../../utils/graphql.js");
 const string_js_1 = require("../../utils/string.js");
 const change_js_1 = require("./change.js");
-function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
+function buildFieldArgumentDescriptionChangedMessage(args) {
+    return `Description for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldDescription}' to '${args.newDescription}'`;
+}
+function fieldArgumentDescriptionChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.FieldArgumentDescriptionChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.NonBreaking,
         },
-        type: change_js_1.ChangeType.FieldArgumentDescriptionChanged,
-        message: `Description for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.description}' to '${newArg.description}'`,
-        path: [type.name, field.name, oldArg.name].join('.'),
+        message: buildFieldArgumentDescriptionChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
+exports.fieldArgumentDescriptionChangedFromMeta = fieldArgumentDescriptionChangedFromMeta;
+function fieldArgumentDescriptionChanged(type, field, oldArg, newArg) {
+    var _a, _b;
+    return fieldArgumentDescriptionChangedFromMeta({
+        type: change_js_1.ChangeType.FieldArgumentDescriptionChanged,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            argumentName: oldArg.name,
+            oldDescription: (_a = oldArg.description) !== null && _a !== void 0 ? _a : null,
+            newDescription: (_b = newArg.description) !== null && _b !== void 0 ? _b : null,
+        },
+    });
+}
 exports.fieldArgumentDescriptionChanged = fieldArgumentDescriptionChanged;
-function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
+function buildFieldArgumentDefaultChangedMessage(args) {
+    return args.oldDefaultValue === undefined
+        ? `Default value '${args.newDefaultValue}' was added to argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}'`
+        : `Default value for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldDefaultValue}' to '${args.newDefaultValue}'`;
+}
+const fieldArgumentDefaultChangedCriticalityDangerousReason = 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.';
+function fieldArgumentDefaultChangedFromMeta(args) {
     return {
+        type: change_js_1.ChangeType.FieldArgumentDefaultChanged,
         criticality: {
             level: change_js_1.CriticalityLevel.Dangerous,
-            reason: 'Changing the default value for an argument may change the runtime behaviour of a field if it was never provided.',
+            reason: fieldArgumentDefaultChangedCriticalityDangerousReason,
         },
-        type: change_js_1.ChangeType.FieldArgumentDefaultChanged,
-        message: typeof oldArg.defaultValue === 'undefined'
-            ? `Default value '${(0, string_js_1.safeString)(newArg.defaultValue)}' was added to argument '${newArg.name}' on field '${type.name}.${field.name}'`
-            : `Default value for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${(0, string_js_1.safeString)(oldArg.defaultValue)}' to '${(0, string_js_1.safeString)(newArg.defaultValue)}'`,
-        path: [type.name, field.name, oldArg.name].join('.'),
+        message: buildFieldArgumentDefaultChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
+exports.fieldArgumentDefaultChangedFromMeta = fieldArgumentDefaultChangedFromMeta;
+function fieldArgumentDefaultChanged(type, field, oldArg, newArg) {
+    const meta = {
+        typeName: type.name,
+        fieldName: field.name,
+        argumentName: newArg.name,
+    };
+    if (oldArg.defaultValue !== undefined) {
+        meta.oldDefaultValue = (0, string_js_1.safeString)(oldArg.defaultValue);
+    }
+    if (newArg.defaultValue !== undefined) {
+        meta.newDefaultValue = (0, string_js_1.safeString)(newArg.defaultValue);
+    }
+    return fieldArgumentDefaultChangedFromMeta({
+        type: change_js_1.ChangeType.FieldArgumentDefaultChanged,
+        meta,
+    });
+}
 exports.fieldArgumentDefaultChanged = fieldArgumentDefaultChanged;
-function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
+function buildFieldArgumentTypeChangedMessage(args) {
+    return `Type for argument '${args.argumentName}' on field '${args.typeName}.${args.fieldName}' changed from '${args.oldArgumentType}' to '${args.newArgumentType}'`;
+}
+const fieldArgumentTypeChangedCriticalityNonBreakingReason = `Changing an input field from non-null to null is considered non-breaking.`;
+const fieldArgumentTypeChangedCriticalityBreakingReason = `Changing the type of a field's argument can cause existing queries that use this argument to error.`;
+function fieldArgumentTypeChangedFromMeta(args) {
     return {
-        criticality: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.type)
+        type: change_js_1.ChangeType.FieldArgumentTypeChanged,
+        criticality: args.meta.isSafeArgumentTypeChange
             ? {
                 level: change_js_1.CriticalityLevel.NonBreaking,
-                reason: `Changing an input field from non-null to null is considered non-breaking.`,
+                reason: fieldArgumentTypeChangedCriticalityNonBreakingReason,
             }
             : {
                 level: change_js_1.CriticalityLevel.Breaking,
-                reason: `Changing the type of a field's argument can cause existing queries that use this argument to error.`,
+                reason: fieldArgumentTypeChangedCriticalityBreakingReason,
             },
-        type: change_js_1.ChangeType.FieldArgumentTypeChanged,
-        message: `Type for argument '${newArg.name}' on field '${type.name}.${field.name}' changed from '${oldArg.type}' to '${newArg.type}'`,
-        path: [type.name, field.name, oldArg.name].join('.'),
+        message: buildFieldArgumentTypeChangedMessage(args.meta),
+        meta: args.meta,
+        path: [args.meta.typeName, args.meta.fieldName, args.meta.argumentName].join('.'),
     };
 }
+exports.fieldArgumentTypeChangedFromMeta = fieldArgumentTypeChangedFromMeta;
+function fieldArgumentTypeChanged(type, field, oldArg, newArg) {
+    return fieldArgumentTypeChangedFromMeta({
+        type: change_js_1.ChangeType.FieldArgumentTypeChanged,
+        meta: {
+            typeName: type.name,
+            fieldName: field.name,
+            argumentName: newArg.name,
+            oldArgumentType: oldArg.type.toString(),
+            newArgumentType: newArg.type.toString(),
+            isSafeArgumentTypeChange: (0, graphql_js_1.safeChangeForInputValue)(oldArg.type, newArg.type),
+        },
+    });
+}
 exports.fieldArgumentTypeChanged = fieldArgumentTypeChanged;