@graphql-inspector/diff-command 3.1.4 → 3.4.0

package/{dist/index.js → index.js}

@@ -10,9 +10,7 @@ const fs = require('fs');
 
 function handler(input) {
     return tslib.__awaiter(this, void 0, void 0, function* () {
-        const onComplete = input.onComplete
-            ? resolveCompletionHandler(input.onComplete)
-            : failOnBreakingChanges;
+        const onComplete = input.onComplete ? resolveCompletionHandler(input.onComplete) : failOnBreakingChanges;
         const rules = input.rules
             ? input.rules
                 .filter(isString)
@@ -23,7 +21,7 @@ function handler(input) {
                 }
                 return rule;
             })
-                .filter((f) => f)
+                .filter(f => f)
             : [];
         const changes = yield core.diff(input.oldSchema, input.newSchema, rules, {
             checkUsage: input.onUsage ? resolveUsageHandler(input.onUsage) : undefined,
@@ -33,9 +31,9 @@ function handler(input) {
             return;
         }
         logger.Logger.log(`\nDetected the following changes (${changes.length}) between schemas:\n`);
-        const breakingChanges = changes.filter((change) => change.criticality.level === core.CriticalityLevel.Breaking);
-        const dangerousChanges = changes.filter((change) => change.criticality.level === core.CriticalityLevel.Dangerous);
-        const nonBreakingChanges = changes.filter((change) => change.criticality.level === core.CriticalityLevel.NonBreaking);
+        const breakingChanges = changes.filter(change => change.criticality.level === core.CriticalityLevel.Breaking);
+        const dangerousChanges = changes.filter(change => change.criticality.level === core.CriticalityLevel.Dangerous);
+        const nonBreakingChanges = changes.filter(change => change.criticality.level === core.CriticalityLevel.NonBreaking);
         if (breakingChanges.length) {
             reportBreakingChanges(breakingChanges);
         }
@@ -48,7 +46,7 @@ function handler(input) {
         onComplete({ breakingChanges, dangerousChanges, nonBreakingChanges });
     });
 }
-const index = commands.createCommand((api) => {
+const index = commands.createCommand(api => {
     const { loaders } = api;
     return {
         command: 'diff <oldSchema> <newSchema>',
@@ -134,21 +132,21 @@ function sortChanges(changes) {
 function reportBreakingChanges(changes) {
     const label = logger.symbols.error;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         logger.Logger.log(`${label}  ${logger.bolderize(change.message)}`);
     });
 }
 function reportDangerousChanges(changes) {
     const label = logger.symbols.warning;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         logger.Logger.log(`${label}  ${logger.bolderize(change.message)}`);
     });
 }
 function reportNonBreakingChanges(changes) {
     const label = logger.symbols.success;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         logger.Logger.log(`${label}  ${logger.bolderize(change.message)}`);
     });
 }

package/{dist/index.mjs → index.mjs}

@@ -6,9 +6,7 @@ import { existsSync } from 'fs';
 
 function handler(input) {
     return __awaiter(this, void 0, void 0, function* () {
-        const onComplete = input.onComplete
-            ? resolveCompletionHandler(input.onComplete)
-            : failOnBreakingChanges;
+        const onComplete = input.onComplete ? resolveCompletionHandler(input.onComplete) : failOnBreakingChanges;
         const rules = input.rules
             ? input.rules
                 .filter(isString)
@@ -19,7 +17,7 @@ function handler(input) {
                 }
                 return rule;
             })
-                .filter((f) => f)
+                .filter(f => f)
             : [];
         const changes = yield diff(input.oldSchema, input.newSchema, rules, {
             checkUsage: input.onUsage ? resolveUsageHandler(input.onUsage) : undefined,
@@ -29,9 +27,9 @@ function handler(input) {
             return;
         }
         Logger.log(`\nDetected the following changes (${changes.length}) between schemas:\n`);
-        const breakingChanges = changes.filter((change) => change.criticality.level === CriticalityLevel.Breaking);
-        const dangerousChanges = changes.filter((change) => change.criticality.level === CriticalityLevel.Dangerous);
-        const nonBreakingChanges = changes.filter((change) => change.criticality.level === CriticalityLevel.NonBreaking);
+        const breakingChanges = changes.filter(change => change.criticality.level === CriticalityLevel.Breaking);
+        const dangerousChanges = changes.filter(change => change.criticality.level === CriticalityLevel.Dangerous);
+        const nonBreakingChanges = changes.filter(change => change.criticality.level === CriticalityLevel.NonBreaking);
         if (breakingChanges.length) {
             reportBreakingChanges(breakingChanges);
         }
@@ -44,7 +42,7 @@ function handler(input) {
         onComplete({ breakingChanges, dangerousChanges, nonBreakingChanges });
     });
 }
-const index = createCommand((api) => {
+const index = createCommand(api => {
     const { loaders } = api;
     return {
         command: 'diff <oldSchema> <newSchema>',
@@ -130,21 +128,21 @@ function sortChanges(changes) {
 function reportBreakingChanges(changes) {
     const label = symbols.error;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         Logger.log(`${label}  ${bolderize(change.message)}`);
     });
 }
 function reportDangerousChanges(changes) {
     const label = symbols.warning;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         Logger.log(`${label}  ${bolderize(change.message)}`);
     });
 }
 function reportNonBreakingChanges(changes) {
     const label = symbols.success;
     const sorted = sortChanges(changes);
-    sorted.forEach((change) => {
+    sorted.forEach(change => {
         Logger.log(`${label}  ${bolderize(change.message)}`);
     });
 }

package/package.json

@@ -1,51 +1,48 @@
 {
   "name": "@graphql-inspector/diff-command",
-  "version": "3.1.4",
+  "version": "3.4.0",
   "description": "Compare GraphQL Schemas",
+  "sideEffects": false,
+  "peerDependencies": {
+    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
+  },
+  "dependencies": {
+    "@graphql-inspector/commands": "3.4.0",
+    "@graphql-inspector/core": "3.4.0",
+    "@graphql-inspector/logger": "3.4.0",
+    "tslib": "^2.0.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "kamilkisiela/graphql-inspector",
+    "directory": "packages/commands/diff"
+  },
   "keywords": [
     "graphql",
     "graphql-inspector",
     "graphql-inspector-command",
     "tools"
   ],
-  "sideEffects": false,
-  "main": "dist/index.js",
-  "module": "dist/index.mjs",
-  "exports": {
-    ".": {
-      "require": "./dist/index.js",
-      "import": "./dist/index.mjs"
-    },
-    "./*": {
-      "require": "./dist/*.js",
-      "import": "./dist/*.mjs"
-    }
-  },
-  "typings": "dist/index.d.ts",
-  "typescript": {
-    "definition": "dist/index.d.ts"
-  },
   "author": {
     "name": "Kamil Kisiela",
     "email": "kamil.kisiela@gmail.com",
     "url": "https://github.com/kamilkisiela"
   },
   "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "kamilkisiela/graphql-inspector",
-    "directory": "packages/commands/diff"
-  },
-  "peerDependencies": {
-    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "dependencies": {
-    "@graphql-inspector/commands": "3.1.4",
-    "@graphql-inspector/core": "3.1.4",
-    "@graphql-inspector/logger": "3.1.4",
-    "tslib": "^2.0.0"
+  "main": "index.js",
+  "module": "index.mjs",
+  "typings": "index.d.ts",
+  "typescript": {
+    "definition": "index.d.ts"
   },
-  "scripts": {
-    "prepack": "bob prepack"
+  "exports": {
+    ".": {
+      "require": "./index.js",
+      "import": "./index.mjs"
+    },
+    "./*": {
+      "require": "./*.js",
+      "import": "./*.mjs"
+    }
   }
 }

package/__tests__/assets/onComplete.js

@@ -1 +0,0 @@
-module.exports = () => process.exit(2);

package/__tests__/assets/rule.js

@@ -1 +0,0 @@
-module.exports = ({ changes }) => changes;

package/__tests__/diff-command.spec.ts

@@ -1,154 +0,0 @@
-import '@graphql-inspector/testing';
-import { mockCommand } from '@graphql-inspector/commands';
-import { mockLogger, unmockLogger } from '@graphql-inspector/logger';
-import yargs from 'yargs';
-import { buildSchema } from 'graphql';
-import { resolve } from 'path';
-import createCommand from '../src';
-
-const oldSchema = buildSchema(/* GraphQL */ `
-  type Post {
-    id: ID
-    title: String
-    createdAt: String
-    modifiedAt: String
-  }
-
-  type Query {
-    post: Post!
-  }
-`);
-const newSchema = buildSchema(/* GraphQL */ `
-  type Post {
-    id: ID!
-    title: String!
-    createdAt: String!
-  }
-
-  type Query {
-    post: Post!
-  }
-`);
-
-const diff = createCommand({
-  config: {
-    commands: [],
-    loaders: [],
-  },
-  loaders: {
-    async loadSchema(pointer) {
-      if (pointer.includes('old')) {
-        return oldSchema;
-      }
-
-      return newSchema;
-    },
-    async loadDocuments() {
-      throw new Error('Not implemented');
-    },
-  },
-});
-
-describe('diff', () => {
-  let spyReporter: jest.SpyInstance;
-  let spyProcessExit: jest.SpyInstance;
-  let spyProcessCwd: jest.SpyInstance;
-
-  beforeEach(() => {
-    yargs.reset();
-    spyProcessExit = jest.spyOn(process, 'exit');
-    spyProcessExit.mockImplementation();
-
-    spyProcessCwd = jest
-      .spyOn(process, 'cwd')
-      .mockImplementation(() => __dirname);
-
-    spyReporter = jest.fn();
-    mockLogger(spyReporter as any);
-  });
-
-  afterEach(() => {
-    yargs.reset();
-    unmockLogger();
-    spyProcessExit.mockRestore();
-    spyProcessCwd.mockRestore();
-    spyReporter.mockRestore();
-  });
-
-  test('should load graphql file', async () => {
-    await mockCommand(diff, 'diff old.graphql old.graphql');
-
-    expect(spyReporter).toHaveBeenCalledNormalized('No changes detected');
-    expect(spyReporter).not.toHaveBeenCalledNormalized(
-      'Detected the following changes',
-    );
-  });
-
-  test('should load different schema from graphql file', async () => {
-    await mockCommand(diff, 'diff old.graphql new.graphql');
-
-    expect(spyReporter).not.toHaveBeenCalledWith('No changes detected');
-    expect(spyReporter).toHaveBeenCalledNormalized(
-      'Detected the following changes (4) between schemas:',
-    );
-
-    expect(spyProcessExit).toHaveBeenCalledWith(1);
-  });
-
-  test('should load rule by name', async () => {
-    await mockCommand(
-      diff,
-      'diff old.graphql new.graphql --rule suppressRemovalOfDeprecatedField',
-    );
-
-    expect(spyReporter).not.toHaveBeenCalledNormalized('does not exist');
-  });
-
-  test('should load rules with local path from fs', async () => {
-    await mockCommand(
-      diff,
-      'diff old.graphql new.graphql --rule ./assets/rule.js',
-    );
-
-    expect(spyReporter).not.toHaveBeenCalledNormalized('does not exist');
-  });
-
-  test('should load rules with absolute path from fs', async () => {
-    await mockCommand(
-      diff,
-      `diff old.graphql new.graphql --rule ${resolve(
-        __dirname,
-        'assets/rule.js',
-      )}`,
-    );
-
-    expect(spyReporter).not.toHaveBeenCalledNormalized('does not exist');
-  });
-
-  test('should render error if file does not exist', async () => {
-    await mockCommand(diff, `diff old.graphql new.graphql --rule noop.js`);
-
-    expect(spyReporter).toHaveBeenCalledNormalized('does not exist');
-  });
-
-  test('should render error if file does not exist', async () => {
-    await mockCommand(
-      diff,
-      `diff old.graphql new.graphql --onComplete ${resolve(
-        __dirname,
-        'assets/onComplete.js',
-      )}`,
-    );
-
-    expect(spyProcessExit).toHaveBeenCalledWith(2);
-  });
-
-  test('should render error if file does not exist', async () => {
-    await mockCommand(
-      diff,
-      `diff old.graphql new.graphql --onComplete noop.js`,
-    );
-
-    expect(spyReporter).toHaveBeenCalledNormalized('does not exist');
-  });
-});

package/dist/package.json

@@ -1,48 +0,0 @@
-{
-  "name": "@graphql-inspector/diff-command",
-  "version": "3.1.4",
-  "description": "Compare GraphQL Schemas",
-  "sideEffects": false,
-  "peerDependencies": {
-    "graphql": "^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
-  },
-  "dependencies": {
-    "@graphql-inspector/commands": "3.1.4",
-    "@graphql-inspector/core": "3.1.4",
-    "@graphql-inspector/logger": "3.1.4",
-    "tslib": "^2.0.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "kamilkisiela/graphql-inspector",
-    "directory": "packages/commands/diff"
-  },
-  "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"
-    }
-  }
-}

package/src/index.ts

@@ -1,283 +0,0 @@
-import {
-  CommandFactory,
-  createCommand,
-  ensureAbsolute,
-  GlobalArgs,
-  parseGlobalArgs,
-} from '@graphql-inspector/commands';
-import {
-  Change,
-  CompletionArgs,
-  CompletionHandler,
-  UsageHandler,
-  CriticalityLevel,
-  diff as diffSchema,
-  DiffRule,
-  Rule,
-} from '@graphql-inspector/core';
-import { bolderize, Logger, symbols } from '@graphql-inspector/logger';
-import { existsSync } from 'fs';
-import { GraphQLSchema } from 'graphql';
-
-export { CommandFactory };
-
-export async function handler(input: {
-  oldSchema: GraphQLSchema;
-  newSchema: GraphQLSchema;
-  onComplete?: string;
-  onUsage?: string;
-  rules?: Array<string | number>;
-}) {
-  const onComplete = input.onComplete
-    ? resolveCompletionHandler(input.onComplete)
-    : failOnBreakingChanges;
-
-  const rules = input.rules
-    ? input.rules
-        .filter(isString)
-        .map((name): Rule => {
-          const rule = resolveRule(name);
-
-          if (!rule) {
-            throw new Error(`\Rule '${name}' does not exist!\n`);
-          }
-
-          return rule;
-        })
-        .filter((f) => f)
-    : [];
-
-  const changes = await diffSchema(input.oldSchema, input.newSchema, rules, {
-    checkUsage: input.onUsage ? resolveUsageHandler(input.onUsage) : undefined,
-  });
-
-  if (changes.length === 0) {
-    Logger.success('No changes detected');
-    return;
-  }
-
-  Logger.log(
-    `\nDetected the following changes (${changes.length}) between schemas:\n`,
-  );
-
-  const breakingChanges = changes.filter(
-    (change) => change.criticality.level === CriticalityLevel.Breaking,
-  );
-  const dangerousChanges = changes.filter(
-    (change) => change.criticality.level === CriticalityLevel.Dangerous,
-  );
-  const nonBreakingChanges = changes.filter(
-    (change) => change.criticality.level === CriticalityLevel.NonBreaking,
-  );
-
-  if (breakingChanges.length) {
-    reportBreakingChanges(breakingChanges);
-  }
-
-  if (dangerousChanges.length) {
-    reportDangerousChanges(dangerousChanges);
-  }
-
-  if (nonBreakingChanges.length) {
-    reportNonBreakingChanges(nonBreakingChanges);
-  }
-
-  onComplete({ breakingChanges, dangerousChanges, nonBreakingChanges });
-}
-
-export default createCommand<
-  {},
-  {
-    oldSchema: string;
-    newSchema: string;
-    rule?: Array<string | number>;
-    onComplete?: string;
-    onUsage?: string;
-  } & GlobalArgs
->((api) => {
-  const { loaders } = api;
-
-  return {
-    command: 'diff <oldSchema> <newSchema>',
-    describe: 'Compare two GraphQL Schemas',
-    builder(yargs) {
-      return yargs
-        .positional('oldSchema', {
-          describe: 'Point to an old schema',
-          type: 'string',
-          demandOption: true,
-        })
-        .positional('newSchema', {
-          describe: 'Point to a new schema',
-          type: 'string',
-          demandOption: true,
-        })
-        .options({
-          rule: {
-            describe: 'Add rules',
-            array: true,
-          },
-          onComplete: {
-            describe: 'Handle Completion',
-            type: 'string',
-          },
-          onUsage: {
-            describe: 'Checks usage of schema',
-            type: 'string',
-          },
-        });
-    },
-    async handler(args) {
-      try {
-        const oldSchemaPointer = args.oldSchema;
-        const newSchemaPointer = args.newSchema;
-        const apolloFederation = args.federation || false;
-        const aws = args.aws || false;
-        const method = args.method?.toUpperCase() || 'POST';
-        const { headers, leftHeaders, rightHeaders, token } =
-          parseGlobalArgs(args);
-
-        const oldSchemaHeaders = {
-          ...(headers ?? {}),
-          ...(leftHeaders ?? {}),
-        };
-        const newSchemaHeaders = {
-          ...(headers ?? {}),
-          ...(rightHeaders ?? {}),
-        };
-
-        const oldSchema = await loaders.loadSchema(
-          oldSchemaPointer,
-          {
-            headers: oldSchemaHeaders,
-            token,
-            method,
-          },
-          apolloFederation,
-          aws,
-        );
-        const newSchema = await loaders.loadSchema(
-          newSchemaPointer,
-          {
-            headers: newSchemaHeaders,
-            token,
-            method,
-          },
-          apolloFederation,
-          aws,
-        );
-
-        await handler({
-          oldSchema,
-          newSchema,
-          rules: args.rule,
-          onComplete: args.onComplete,
-          onUsage: args.onUsage,
-        });
-      } catch (error) {
-        Logger.error(error);
-        throw error;
-      }
-    },
-  };
-});
-
-function sortChanges(changes: Change[]) {
-  return changes.slice().sort((a, b) => {
-    const aPath = a.path || '';
-    const bPath = b.path || '';
-
-    if (aPath > bPath) {
-      return 1;
-    }
-
-    if (bPath > aPath) {
-      return -1;
-    }
-
-    return 0;
-  });
-}
-
-function reportBreakingChanges(changes: Change[]) {
-  const label = symbols.error;
-  const sorted = sortChanges(changes);
-
-  sorted.forEach((change) => {
-    Logger.log(`${label}  ${bolderize(change.message)}`);
-  });
-}
-
-function reportDangerousChanges(changes: Change[]) {
-  const label = symbols.warning;
-  const sorted = sortChanges(changes);
-
-  sorted.forEach((change) => {
-    Logger.log(`${label}  ${bolderize(change.message)}`);
-  });
-}
-
-function reportNonBreakingChanges(changes: Change[]) {
-  const label = symbols.success;
-  const sorted = sortChanges(changes);
-
-  sorted.forEach((change) => {
-    Logger.log(`${label}  ${bolderize(change.message)}`);
-  });
-}
-
-function resolveRule(name: string): Rule | undefined {
-  const filepath = ensureAbsolute(name);
-  if (existsSync(filepath)) {
-    return require(filepath);
-  }
-
-  return DiffRule[name as keyof typeof DiffRule];
-}
-
-function resolveCompletionHandler(name: string): CompletionHandler | never {
-  const filepath = ensureAbsolute(name);
-
-  try {
-    require.resolve(filepath);
-  } catch (error) {
-    throw new Error(`CompletionHandler '${name}' does not exist!`);
-  }
-
-  const mod = require(filepath);
-
-  return mod?.default || mod;
-}
-
-function resolveUsageHandler(name: string): UsageHandler | never {
-  const filepath = ensureAbsolute(name);
-
-  try {
-    require.resolve(filepath);
-  } catch (error) {
-    throw new Error(`UsageHandler '${name}' does not exist!`);
-  }
-
-  const mod = require(filepath);
-
-  return mod?.default || mod;
-}
-
-function failOnBreakingChanges({ breakingChanges }: CompletionArgs) {
-  const breakingCount = breakingChanges.length;
-
-  if (breakingCount) {
-    Logger.error(
-      `Detected ${breakingCount} breaking change${
-        breakingCount > 1 ? 's' : ''
-      }`,
-    );
-    process.exit(1);
-  } else {
-    Logger.success('No breaking changes detected');
-  }
-}
-
-function isString(val: any): val is string {
-  return typeof val === 'string';
-}