@slicemachine/manager 0.1.1-dev-plugins.3

package/dist/__node_modules/graphql/utilities/findBreakingChanges.cjs

@@ -0,0 +1,384 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const inspect = require("../jsutils/inspect.cjs");
+const invariant = require("../jsutils/invariant.cjs");
+const keyMap = require("../jsutils/keyMap.cjs");
+const printer = require("../language/printer.cjs");
+const definition = require("../type/definition.cjs");
+const scalars = require("../type/scalars.cjs");
+const astFromValue = require("./astFromValue.cjs");
+const sortValueNode = require("./sortValueNode.cjs");
+exports.BreakingChangeType = void 0;
+(function(BreakingChangeType) {
+  BreakingChangeType["TYPE_REMOVED"] = "TYPE_REMOVED";
+  BreakingChangeType["TYPE_CHANGED_KIND"] = "TYPE_CHANGED_KIND";
+  BreakingChangeType["TYPE_REMOVED_FROM_UNION"] = "TYPE_REMOVED_FROM_UNION";
+  BreakingChangeType["VALUE_REMOVED_FROM_ENUM"] = "VALUE_REMOVED_FROM_ENUM";
+  BreakingChangeType["REQUIRED_INPUT_FIELD_ADDED"] = "REQUIRED_INPUT_FIELD_ADDED";
+  BreakingChangeType["IMPLEMENTED_INTERFACE_REMOVED"] = "IMPLEMENTED_INTERFACE_REMOVED";
+  BreakingChangeType["FIELD_REMOVED"] = "FIELD_REMOVED";
+  BreakingChangeType["FIELD_CHANGED_KIND"] = "FIELD_CHANGED_KIND";
+  BreakingChangeType["REQUIRED_ARG_ADDED"] = "REQUIRED_ARG_ADDED";
+  BreakingChangeType["ARG_REMOVED"] = "ARG_REMOVED";
+  BreakingChangeType["ARG_CHANGED_KIND"] = "ARG_CHANGED_KIND";
+  BreakingChangeType["DIRECTIVE_REMOVED"] = "DIRECTIVE_REMOVED";
+  BreakingChangeType["DIRECTIVE_ARG_REMOVED"] = "DIRECTIVE_ARG_REMOVED";
+  BreakingChangeType["REQUIRED_DIRECTIVE_ARG_ADDED"] = "REQUIRED_DIRECTIVE_ARG_ADDED";
+  BreakingChangeType["DIRECTIVE_REPEATABLE_REMOVED"] = "DIRECTIVE_REPEATABLE_REMOVED";
+  BreakingChangeType["DIRECTIVE_LOCATION_REMOVED"] = "DIRECTIVE_LOCATION_REMOVED";
+})(exports.BreakingChangeType || (exports.BreakingChangeType = {}));
+exports.DangerousChangeType = void 0;
+(function(DangerousChangeType) {
+  DangerousChangeType["VALUE_ADDED_TO_ENUM"] = "VALUE_ADDED_TO_ENUM";
+  DangerousChangeType["TYPE_ADDED_TO_UNION"] = "TYPE_ADDED_TO_UNION";
+  DangerousChangeType["OPTIONAL_INPUT_FIELD_ADDED"] = "OPTIONAL_INPUT_FIELD_ADDED";
+  DangerousChangeType["OPTIONAL_ARG_ADDED"] = "OPTIONAL_ARG_ADDED";
+  DangerousChangeType["IMPLEMENTED_INTERFACE_ADDED"] = "IMPLEMENTED_INTERFACE_ADDED";
+  DangerousChangeType["ARG_DEFAULT_VALUE_CHANGE"] = "ARG_DEFAULT_VALUE_CHANGE";
+})(exports.DangerousChangeType || (exports.DangerousChangeType = {}));
+function findBreakingChanges(oldSchema, newSchema) {
+  return findSchemaChanges(oldSchema, newSchema).filter(
+    (change) => change.type in exports.BreakingChangeType
+  );
+}
+function findDangerousChanges(oldSchema, newSchema) {
+  return findSchemaChanges(oldSchema, newSchema).filter(
+    (change) => change.type in exports.DangerousChangeType
+  );
+}
+function findSchemaChanges(oldSchema, newSchema) {
+  return [
+    ...findTypeChanges(oldSchema, newSchema),
+    ...findDirectiveChanges(oldSchema, newSchema)
+  ];
+}
+function findDirectiveChanges(oldSchema, newSchema) {
+  const schemaChanges = [];
+  const directivesDiff = diff(
+    oldSchema.getDirectives(),
+    newSchema.getDirectives()
+  );
+  for (const oldDirective of directivesDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.DIRECTIVE_REMOVED,
+      description: `${oldDirective.name} was removed.`
+    });
+  }
+  for (const [oldDirective, newDirective] of directivesDiff.persisted) {
+    const argsDiff = diff(oldDirective.args, newDirective.args);
+    for (const newArg of argsDiff.added) {
+      if (definition.isRequiredArgument(newArg)) {
+        schemaChanges.push({
+          type: exports.BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED,
+          description: `A required arg ${newArg.name} on directive ${oldDirective.name} was added.`
+        });
+      }
+    }
+    for (const oldArg of argsDiff.removed) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.DIRECTIVE_ARG_REMOVED,
+        description: `${oldArg.name} was removed from ${oldDirective.name}.`
+      });
+    }
+    if (oldDirective.isRepeatable && !newDirective.isRepeatable) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.DIRECTIVE_REPEATABLE_REMOVED,
+        description: `Repeatable flag was removed from ${oldDirective.name}.`
+      });
+    }
+    for (const location of oldDirective.locations) {
+      if (!newDirective.locations.includes(location)) {
+        schemaChanges.push({
+          type: exports.BreakingChangeType.DIRECTIVE_LOCATION_REMOVED,
+          description: `${location} was removed from ${oldDirective.name}.`
+        });
+      }
+    }
+  }
+  return schemaChanges;
+}
+function findTypeChanges(oldSchema, newSchema) {
+  const schemaChanges = [];
+  const typesDiff = diff(
+    Object.values(oldSchema.getTypeMap()),
+    Object.values(newSchema.getTypeMap())
+  );
+  for (const oldType of typesDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.TYPE_REMOVED,
+      description: scalars.isSpecifiedScalarType(oldType) ? `Standard scalar ${oldType.name} was removed because it is not referenced anymore.` : `${oldType.name} was removed.`
+    });
+  }
+  for (const [oldType, newType] of typesDiff.persisted) {
+    if (definition.isEnumType(oldType) && definition.isEnumType(newType)) {
+      schemaChanges.push(...findEnumTypeChanges(oldType, newType));
+    } else if (definition.isUnionType(oldType) && definition.isUnionType(newType)) {
+      schemaChanges.push(...findUnionTypeChanges(oldType, newType));
+    } else if (definition.isInputObjectType(oldType) && definition.isInputObjectType(newType)) {
+      schemaChanges.push(...findInputObjectTypeChanges(oldType, newType));
+    } else if (definition.isObjectType(oldType) && definition.isObjectType(newType)) {
+      schemaChanges.push(
+        ...findFieldChanges(oldType, newType),
+        ...findImplementedInterfacesChanges(oldType, newType)
+      );
+    } else if (definition.isInterfaceType(oldType) && definition.isInterfaceType(newType)) {
+      schemaChanges.push(
+        ...findFieldChanges(oldType, newType),
+        ...findImplementedInterfacesChanges(oldType, newType)
+      );
+    } else if (oldType.constructor !== newType.constructor) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.TYPE_CHANGED_KIND,
+        description: `${oldType.name} changed from ${typeKindName(oldType)} to ${typeKindName(newType)}.`
+      });
+    }
+  }
+  return schemaChanges;
+}
+function findInputObjectTypeChanges(oldType, newType) {
+  const schemaChanges = [];
+  const fieldsDiff = diff(
+    Object.values(oldType.getFields()),
+    Object.values(newType.getFields())
+  );
+  for (const newField of fieldsDiff.added) {
+    if (definition.isRequiredInputField(newField)) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED,
+        description: `A required field ${newField.name} on input type ${oldType.name} was added.`
+      });
+    } else {
+      schemaChanges.push({
+        type: exports.DangerousChangeType.OPTIONAL_INPUT_FIELD_ADDED,
+        description: `An optional field ${newField.name} on input type ${oldType.name} was added.`
+      });
+    }
+  }
+  for (const oldField of fieldsDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.FIELD_REMOVED,
+      description: `${oldType.name}.${oldField.name} was removed.`
+    });
+  }
+  for (const [oldField, newField] of fieldsDiff.persisted) {
+    const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(
+      oldField.type,
+      newField.type
+    );
+    if (!isSafe) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.FIELD_CHANGED_KIND,
+        description: `${oldType.name}.${oldField.name} changed type from ${String(oldField.type)} to ${String(newField.type)}.`
+      });
+    }
+  }
+  return schemaChanges;
+}
+function findUnionTypeChanges(oldType, newType) {
+  const schemaChanges = [];
+  const possibleTypesDiff = diff(oldType.getTypes(), newType.getTypes());
+  for (const newPossibleType of possibleTypesDiff.added) {
+    schemaChanges.push({
+      type: exports.DangerousChangeType.TYPE_ADDED_TO_UNION,
+      description: `${newPossibleType.name} was added to union type ${oldType.name}.`
+    });
+  }
+  for (const oldPossibleType of possibleTypesDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.TYPE_REMOVED_FROM_UNION,
+      description: `${oldPossibleType.name} was removed from union type ${oldType.name}.`
+    });
+  }
+  return schemaChanges;
+}
+function findEnumTypeChanges(oldType, newType) {
+  const schemaChanges = [];
+  const valuesDiff = diff(oldType.getValues(), newType.getValues());
+  for (const newValue of valuesDiff.added) {
+    schemaChanges.push({
+      type: exports.DangerousChangeType.VALUE_ADDED_TO_ENUM,
+      description: `${newValue.name} was added to enum type ${oldType.name}.`
+    });
+  }
+  for (const oldValue of valuesDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.VALUE_REMOVED_FROM_ENUM,
+      description: `${oldValue.name} was removed from enum type ${oldType.name}.`
+    });
+  }
+  return schemaChanges;
+}
+function findImplementedInterfacesChanges(oldType, newType) {
+  const schemaChanges = [];
+  const interfacesDiff = diff(oldType.getInterfaces(), newType.getInterfaces());
+  for (const newInterface of interfacesDiff.added) {
+    schemaChanges.push({
+      type: exports.DangerousChangeType.IMPLEMENTED_INTERFACE_ADDED,
+      description: `${newInterface.name} added to interfaces implemented by ${oldType.name}.`
+    });
+  }
+  for (const oldInterface of interfacesDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.IMPLEMENTED_INTERFACE_REMOVED,
+      description: `${oldType.name} no longer implements interface ${oldInterface.name}.`
+    });
+  }
+  return schemaChanges;
+}
+function findFieldChanges(oldType, newType) {
+  const schemaChanges = [];
+  const fieldsDiff = diff(
+    Object.values(oldType.getFields()),
+    Object.values(newType.getFields())
+  );
+  for (const oldField of fieldsDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.FIELD_REMOVED,
+      description: `${oldType.name}.${oldField.name} was removed.`
+    });
+  }
+  for (const [oldField, newField] of fieldsDiff.persisted) {
+    schemaChanges.push(...findArgChanges(oldType, oldField, newField));
+    const isSafe = isChangeSafeForObjectOrInterfaceField(
+      oldField.type,
+      newField.type
+    );
+    if (!isSafe) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.FIELD_CHANGED_KIND,
+        description: `${oldType.name}.${oldField.name} changed type from ${String(oldField.type)} to ${String(newField.type)}.`
+      });
+    }
+  }
+  return schemaChanges;
+}
+function findArgChanges(oldType, oldField, newField) {
+  const schemaChanges = [];
+  const argsDiff = diff(oldField.args, newField.args);
+  for (const oldArg of argsDiff.removed) {
+    schemaChanges.push({
+      type: exports.BreakingChangeType.ARG_REMOVED,
+      description: `${oldType.name}.${oldField.name} arg ${oldArg.name} was removed.`
+    });
+  }
+  for (const [oldArg, newArg] of argsDiff.persisted) {
+    const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(
+      oldArg.type,
+      newArg.type
+    );
+    if (!isSafe) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.ARG_CHANGED_KIND,
+        description: `${oldType.name}.${oldField.name} arg ${oldArg.name} has changed type from ${String(oldArg.type)} to ${String(newArg.type)}.`
+      });
+    } else if (oldArg.defaultValue !== void 0) {
+      if (newArg.defaultValue === void 0) {
+        schemaChanges.push({
+          type: exports.DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+          description: `${oldType.name}.${oldField.name} arg ${oldArg.name} defaultValue was removed.`
+        });
+      } else {
+        const oldValueStr = stringifyValue(oldArg.defaultValue, oldArg.type);
+        const newValueStr = stringifyValue(newArg.defaultValue, newArg.type);
+        if (oldValueStr !== newValueStr) {
+          schemaChanges.push({
+            type: exports.DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,
+            description: `${oldType.name}.${oldField.name} arg ${oldArg.name} has changed defaultValue from ${oldValueStr} to ${newValueStr}.`
+          });
+        }
+      }
+    }
+  }
+  for (const newArg of argsDiff.added) {
+    if (definition.isRequiredArgument(newArg)) {
+      schemaChanges.push({
+        type: exports.BreakingChangeType.REQUIRED_ARG_ADDED,
+        description: `A required arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`
+      });
+    } else {
+      schemaChanges.push({
+        type: exports.DangerousChangeType.OPTIONAL_ARG_ADDED,
+        description: `An optional arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`
+      });
+    }
+  }
+  return schemaChanges;
+}
+function isChangeSafeForObjectOrInterfaceField(oldType, newType) {
+  if (definition.isListType(oldType)) {
+    return definition.isListType(newType) && isChangeSafeForObjectOrInterfaceField(
+      oldType.ofType,
+      newType.ofType
+    ) || definition.isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType);
+  }
+  if (definition.isNonNullType(oldType)) {
+    return definition.isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType);
+  }
+  return definition.isNamedType(newType) && oldType.name === newType.name || definition.isNonNullType(newType) && isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType);
+}
+function isChangeSafeForInputObjectFieldOrFieldArg(oldType, newType) {
+  if (definition.isListType(oldType)) {
+    return definition.isListType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType);
+  }
+  if (definition.isNonNullType(oldType)) {
+    return definition.isNonNullType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(
+      oldType.ofType,
+      newType.ofType
+    ) || !definition.isNonNullType(newType) && isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType);
+  }
+  return definition.isNamedType(newType) && oldType.name === newType.name;
+}
+function typeKindName(type) {
+  if (definition.isScalarType(type)) {
+    return "a Scalar type";
+  }
+  if (definition.isObjectType(type)) {
+    return "an Object type";
+  }
+  if (definition.isInterfaceType(type)) {
+    return "an Interface type";
+  }
+  if (definition.isUnionType(type)) {
+    return "a Union type";
+  }
+  if (definition.isEnumType(type)) {
+    return "an Enum type";
+  }
+  if (definition.isInputObjectType(type)) {
+    return "an Input type";
+  }
+  invariant.invariant(false, "Unexpected type: " + inspect.inspect(type));
+}
+function stringifyValue(value, type) {
+  const ast = astFromValue.astFromValue(value, type);
+  ast != null || invariant.invariant(false);
+  return printer.print(sortValueNode.sortValueNode(ast));
+}
+function diff(oldArray, newArray) {
+  const added = [];
+  const removed = [];
+  const persisted = [];
+  const oldMap = keyMap.keyMap(oldArray, ({ name }) => name);
+  const newMap = keyMap.keyMap(newArray, ({ name }) => name);
+  for (const oldItem of oldArray) {
+    const newItem = newMap[oldItem.name];
+    if (newItem === void 0) {
+      removed.push(oldItem);
+    } else {
+      persisted.push([oldItem, newItem]);
+    }
+  }
+  for (const newItem of newArray) {
+    if (oldMap[newItem.name] === void 0) {
+      added.push(newItem);
+    }
+  }
+  return {
+    added,
+    persisted,
+    removed
+  };
+}
+exports.findBreakingChanges = findBreakingChanges;
+exports.findDangerousChanges = findDangerousChanges;
+//# sourceMappingURL=findBreakingChanges.cjs.map

package/dist/__node_modules/graphql/utilities/findBreakingChanges.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"findBreakingChanges.cjs","sources":["../../../../../../node_modules/graphql/utilities/findBreakingChanges.mjs"],"sourcesContent":["import { inspect } from '../jsutils/inspect.mjs';\nimport { invariant } from '../jsutils/invariant.mjs';\nimport { keyMap } from '../jsutils/keyMap.mjs';\nimport { print } from '../language/printer.mjs';\nimport {\n  isEnumType,\n  isInputObjectType,\n  isInterfaceType,\n  isListType,\n  isNamedType,\n  isNonNullType,\n  isObjectType,\n  isRequiredArgument,\n  isRequiredInputField,\n  isScalarType,\n  isUnionType,\n} from '../type/definition.mjs';\nimport { isSpecifiedScalarType } from '../type/scalars.mjs';\nimport { astFromValue } from './astFromValue.mjs';\nimport { sortValueNode } from './sortValueNode.mjs';\nvar BreakingChangeType;\n\n(function (BreakingChangeType) {\n  BreakingChangeType['TYPE_REMOVED'] = 'TYPE_REMOVED';\n  BreakingChangeType['TYPE_CHANGED_KIND'] = 'TYPE_CHANGED_KIND';\n  BreakingChangeType['TYPE_REMOVED_FROM_UNION'] = 'TYPE_REMOVED_FROM_UNION';\n  BreakingChangeType['VALUE_REMOVED_FROM_ENUM'] = 'VALUE_REMOVED_FROM_ENUM';\n  BreakingChangeType['REQUIRED_INPUT_FIELD_ADDED'] =\n    'REQUIRED_INPUT_FIELD_ADDED';\n  BreakingChangeType['IMPLEMENTED_INTERFACE_REMOVED'] =\n    'IMPLEMENTED_INTERFACE_REMOVED';\n  BreakingChangeType['FIELD_REMOVED'] = 'FIELD_REMOVED';\n  BreakingChangeType['FIELD_CHANGED_KIND'] = 'FIELD_CHANGED_KIND';\n  BreakingChangeType['REQUIRED_ARG_ADDED'] = 'REQUIRED_ARG_ADDED';\n  BreakingChangeType['ARG_REMOVED'] = 'ARG_REMOVED';\n  BreakingChangeType['ARG_CHANGED_KIND'] = 'ARG_CHANGED_KIND';\n  BreakingChangeType['DIRECTIVE_REMOVED'] = 'DIRECTIVE_REMOVED';\n  BreakingChangeType['DIRECTIVE_ARG_REMOVED'] = 'DIRECTIVE_ARG_REMOVED';\n  BreakingChangeType['REQUIRED_DIRECTIVE_ARG_ADDED'] =\n    'REQUIRED_DIRECTIVE_ARG_ADDED';\n  BreakingChangeType['DIRECTIVE_REPEATABLE_REMOVED'] =\n    'DIRECTIVE_REPEATABLE_REMOVED';\n  BreakingChangeType['DIRECTIVE_LOCATION_REMOVED'] =\n    'DIRECTIVE_LOCATION_REMOVED';\n})(BreakingChangeType || (BreakingChangeType = {}));\n\nexport { BreakingChangeType };\nvar DangerousChangeType;\n\n(function (DangerousChangeType) {\n  DangerousChangeType['VALUE_ADDED_TO_ENUM'] = 'VALUE_ADDED_TO_ENUM';\n  DangerousChangeType['TYPE_ADDED_TO_UNION'] = 'TYPE_ADDED_TO_UNION';\n  DangerousChangeType['OPTIONAL_INPUT_FIELD_ADDED'] =\n    'OPTIONAL_INPUT_FIELD_ADDED';\n  DangerousChangeType['OPTIONAL_ARG_ADDED'] = 'OPTIONAL_ARG_ADDED';\n  DangerousChangeType['IMPLEMENTED_INTERFACE_ADDED'] =\n    'IMPLEMENTED_INTERFACE_ADDED';\n  DangerousChangeType['ARG_DEFAULT_VALUE_CHANGE'] = 'ARG_DEFAULT_VALUE_CHANGE';\n})(DangerousChangeType || (DangerousChangeType = {}));\n\nexport { DangerousChangeType };\n\n/**\n * Given two schemas, returns an Array containing descriptions of all the types\n * of breaking changes covered by the other functions down below.\n */\nexport function findBreakingChanges(oldSchema, newSchema) {\n  // @ts-expect-error\n  return findSchemaChanges(oldSchema, newSchema).filter(\n    (change) => change.type in BreakingChangeType,\n  );\n}\n/**\n * Given two schemas, returns an Array containing descriptions of all the types\n * of potentially dangerous changes covered by the other functions down below.\n */\n\nexport function findDangerousChanges(oldSchema, newSchema) {\n  // @ts-expect-error\n  return findSchemaChanges(oldSchema, newSchema).filter(\n    (change) => change.type in DangerousChangeType,\n  );\n}\n\nfunction findSchemaChanges(oldSchema, newSchema) {\n  return [\n    ...findTypeChanges(oldSchema, newSchema),\n    ...findDirectiveChanges(oldSchema, newSchema),\n  ];\n}\n\nfunction findDirectiveChanges(oldSchema, newSchema) {\n  const schemaChanges = [];\n  const directivesDiff = diff(\n    oldSchema.getDirectives(),\n    newSchema.getDirectives(),\n  );\n\n  for (const oldDirective of directivesDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.DIRECTIVE_REMOVED,\n      description: `${oldDirective.name} was removed.`,\n    });\n  }\n\n  for (const [oldDirective, newDirective] of directivesDiff.persisted) {\n    const argsDiff = diff(oldDirective.args, newDirective.args);\n\n    for (const newArg of argsDiff.added) {\n      if (isRequiredArgument(newArg)) {\n        schemaChanges.push({\n          type: BreakingChangeType.REQUIRED_DIRECTIVE_ARG_ADDED,\n          description: `A required arg ${newArg.name} on directive ${oldDirective.name} was added.`,\n        });\n      }\n    }\n\n    for (const oldArg of argsDiff.removed) {\n      schemaChanges.push({\n        type: BreakingChangeType.DIRECTIVE_ARG_REMOVED,\n        description: `${oldArg.name} was removed from ${oldDirective.name}.`,\n      });\n    }\n\n    if (oldDirective.isRepeatable && !newDirective.isRepeatable) {\n      schemaChanges.push({\n        type: BreakingChangeType.DIRECTIVE_REPEATABLE_REMOVED,\n        description: `Repeatable flag was removed from ${oldDirective.name}.`,\n      });\n    }\n\n    for (const location of oldDirective.locations) {\n      if (!newDirective.locations.includes(location)) {\n        schemaChanges.push({\n          type: BreakingChangeType.DIRECTIVE_LOCATION_REMOVED,\n          description: `${location} was removed from ${oldDirective.name}.`,\n        });\n      }\n    }\n  }\n\n  return schemaChanges;\n}\n\nfunction findTypeChanges(oldSchema, newSchema) {\n  const schemaChanges = [];\n  const typesDiff = diff(\n    Object.values(oldSchema.getTypeMap()),\n    Object.values(newSchema.getTypeMap()),\n  );\n\n  for (const oldType of typesDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.TYPE_REMOVED,\n      description: isSpecifiedScalarType(oldType)\n        ? `Standard scalar ${oldType.name} was removed because it is not referenced anymore.`\n        : `${oldType.name} was removed.`,\n    });\n  }\n\n  for (const [oldType, newType] of typesDiff.persisted) {\n    if (isEnumType(oldType) && isEnumType(newType)) {\n      schemaChanges.push(...findEnumTypeChanges(oldType, newType));\n    } else if (isUnionType(oldType) && isUnionType(newType)) {\n      schemaChanges.push(...findUnionTypeChanges(oldType, newType));\n    } else if (isInputObjectType(oldType) && isInputObjectType(newType)) {\n      schemaChanges.push(...findInputObjectTypeChanges(oldType, newType));\n    } else if (isObjectType(oldType) && isObjectType(newType)) {\n      schemaChanges.push(\n        ...findFieldChanges(oldType, newType),\n        ...findImplementedInterfacesChanges(oldType, newType),\n      );\n    } else if (isInterfaceType(oldType) && isInterfaceType(newType)) {\n      schemaChanges.push(\n        ...findFieldChanges(oldType, newType),\n        ...findImplementedInterfacesChanges(oldType, newType),\n      );\n    } else if (oldType.constructor !== newType.constructor) {\n      schemaChanges.push({\n        type: BreakingChangeType.TYPE_CHANGED_KIND,\n        description:\n          `${oldType.name} changed from ` +\n          `${typeKindName(oldType)} to ${typeKindName(newType)}.`,\n      });\n    }\n  }\n\n  return schemaChanges;\n}\n\nfunction findInputObjectTypeChanges(oldType, newType) {\n  const schemaChanges = [];\n  const fieldsDiff = diff(\n    Object.values(oldType.getFields()),\n    Object.values(newType.getFields()),\n  );\n\n  for (const newField of fieldsDiff.added) {\n    if (isRequiredInputField(newField)) {\n      schemaChanges.push({\n        type: BreakingChangeType.REQUIRED_INPUT_FIELD_ADDED,\n        description: `A required field ${newField.name} on input type ${oldType.name} was added.`,\n      });\n    } else {\n      schemaChanges.push({\n        type: DangerousChangeType.OPTIONAL_INPUT_FIELD_ADDED,\n        description: `An optional field ${newField.name} on input type ${oldType.name} was added.`,\n      });\n    }\n  }\n\n  for (const oldField of fieldsDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.FIELD_REMOVED,\n      description: `${oldType.name}.${oldField.name} was removed.`,\n    });\n  }\n\n  for (const [oldField, newField] of fieldsDiff.persisted) {\n    const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(\n      oldField.type,\n      newField.type,\n    );\n\n    if (!isSafe) {\n      schemaChanges.push({\n        type: BreakingChangeType.FIELD_CHANGED_KIND,\n        description:\n          `${oldType.name}.${oldField.name} changed type from ` +\n          `${String(oldField.type)} to ${String(newField.type)}.`,\n      });\n    }\n  }\n\n  return schemaChanges;\n}\n\nfunction findUnionTypeChanges(oldType, newType) {\n  const schemaChanges = [];\n  const possibleTypesDiff = diff(oldType.getTypes(), newType.getTypes());\n\n  for (const newPossibleType of possibleTypesDiff.added) {\n    schemaChanges.push({\n      type: DangerousChangeType.TYPE_ADDED_TO_UNION,\n      description: `${newPossibleType.name} was added to union type ${oldType.name}.`,\n    });\n  }\n\n  for (const oldPossibleType of possibleTypesDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.TYPE_REMOVED_FROM_UNION,\n      description: `${oldPossibleType.name} was removed from union type ${oldType.name}.`,\n    });\n  }\n\n  return schemaChanges;\n}\n\nfunction findEnumTypeChanges(oldType, newType) {\n  const schemaChanges = [];\n  const valuesDiff = diff(oldType.getValues(), newType.getValues());\n\n  for (const newValue of valuesDiff.added) {\n    schemaChanges.push({\n      type: DangerousChangeType.VALUE_ADDED_TO_ENUM,\n      description: `${newValue.name} was added to enum type ${oldType.name}.`,\n    });\n  }\n\n  for (const oldValue of valuesDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.VALUE_REMOVED_FROM_ENUM,\n      description: `${oldValue.name} was removed from enum type ${oldType.name}.`,\n    });\n  }\n\n  return schemaChanges;\n}\n\nfunction findImplementedInterfacesChanges(oldType, newType) {\n  const schemaChanges = [];\n  const interfacesDiff = diff(oldType.getInterfaces(), newType.getInterfaces());\n\n  for (const newInterface of interfacesDiff.added) {\n    schemaChanges.push({\n      type: DangerousChangeType.IMPLEMENTED_INTERFACE_ADDED,\n      description: `${newInterface.name} added to interfaces implemented by ${oldType.name}.`,\n    });\n  }\n\n  for (const oldInterface of interfacesDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.IMPLEMENTED_INTERFACE_REMOVED,\n      description: `${oldType.name} no longer implements interface ${oldInterface.name}.`,\n    });\n  }\n\n  return schemaChanges;\n}\n\nfunction findFieldChanges(oldType, newType) {\n  const schemaChanges = [];\n  const fieldsDiff = diff(\n    Object.values(oldType.getFields()),\n    Object.values(newType.getFields()),\n  );\n\n  for (const oldField of fieldsDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.FIELD_REMOVED,\n      description: `${oldType.name}.${oldField.name} was removed.`,\n    });\n  }\n\n  for (const [oldField, newField] of fieldsDiff.persisted) {\n    schemaChanges.push(...findArgChanges(oldType, oldField, newField));\n    const isSafe = isChangeSafeForObjectOrInterfaceField(\n      oldField.type,\n      newField.type,\n    );\n\n    if (!isSafe) {\n      schemaChanges.push({\n        type: BreakingChangeType.FIELD_CHANGED_KIND,\n        description:\n          `${oldType.name}.${oldField.name} changed type from ` +\n          `${String(oldField.type)} to ${String(newField.type)}.`,\n      });\n    }\n  }\n\n  return schemaChanges;\n}\n\nfunction findArgChanges(oldType, oldField, newField) {\n  const schemaChanges = [];\n  const argsDiff = diff(oldField.args, newField.args);\n\n  for (const oldArg of argsDiff.removed) {\n    schemaChanges.push({\n      type: BreakingChangeType.ARG_REMOVED,\n      description: `${oldType.name}.${oldField.name} arg ${oldArg.name} was removed.`,\n    });\n  }\n\n  for (const [oldArg, newArg] of argsDiff.persisted) {\n    const isSafe = isChangeSafeForInputObjectFieldOrFieldArg(\n      oldArg.type,\n      newArg.type,\n    );\n\n    if (!isSafe) {\n      schemaChanges.push({\n        type: BreakingChangeType.ARG_CHANGED_KIND,\n        description:\n          `${oldType.name}.${oldField.name} arg ${oldArg.name} has changed type from ` +\n          `${String(oldArg.type)} to ${String(newArg.type)}.`,\n      });\n    } else if (oldArg.defaultValue !== undefined) {\n      if (newArg.defaultValue === undefined) {\n        schemaChanges.push({\n          type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,\n          description: `${oldType.name}.${oldField.name} arg ${oldArg.name} defaultValue was removed.`,\n        });\n      } else {\n        // Since we looking only for client's observable changes we should\n        // compare default values in the same representation as they are\n        // represented inside introspection.\n        const oldValueStr = stringifyValue(oldArg.defaultValue, oldArg.type);\n        const newValueStr = stringifyValue(newArg.defaultValue, newArg.type);\n\n        if (oldValueStr !== newValueStr) {\n          schemaChanges.push({\n            type: DangerousChangeType.ARG_DEFAULT_VALUE_CHANGE,\n            description: `${oldType.name}.${oldField.name} arg ${oldArg.name} has changed defaultValue from ${oldValueStr} to ${newValueStr}.`,\n          });\n        }\n      }\n    }\n  }\n\n  for (const newArg of argsDiff.added) {\n    if (isRequiredArgument(newArg)) {\n      schemaChanges.push({\n        type: BreakingChangeType.REQUIRED_ARG_ADDED,\n        description: `A required arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`,\n      });\n    } else {\n      schemaChanges.push({\n        type: DangerousChangeType.OPTIONAL_ARG_ADDED,\n        description: `An optional arg ${newArg.name} on ${oldType.name}.${oldField.name} was added.`,\n      });\n    }\n  }\n\n  return schemaChanges;\n}\n\nfunction isChangeSafeForObjectOrInterfaceField(oldType, newType) {\n  if (isListType(oldType)) {\n    return (\n      // if they're both lists, make sure the underlying types are compatible\n      (isListType(newType) &&\n        isChangeSafeForObjectOrInterfaceField(\n          oldType.ofType,\n          newType.ofType,\n        )) || // moving from nullable to non-null of the same underlying type is safe\n      (isNonNullType(newType) &&\n        isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))\n    );\n  }\n\n  if (isNonNullType(oldType)) {\n    // if they're both non-null, make sure the underlying types are compatible\n    return (\n      isNonNullType(newType) &&\n      isChangeSafeForObjectOrInterfaceField(oldType.ofType, newType.ofType)\n    );\n  }\n\n  return (\n    // if they're both named types, see if their names are equivalent\n    (isNamedType(newType) && oldType.name === newType.name) || // moving from nullable to non-null of the same underlying type is safe\n    (isNonNullType(newType) &&\n      isChangeSafeForObjectOrInterfaceField(oldType, newType.ofType))\n  );\n}\n\nfunction isChangeSafeForInputObjectFieldOrFieldArg(oldType, newType) {\n  if (isListType(oldType)) {\n    // if they're both lists, make sure the underlying types are compatible\n    return (\n      isListType(newType) &&\n      isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType.ofType)\n    );\n  }\n\n  if (isNonNullType(oldType)) {\n    return (\n      // if they're both non-null, make sure the underlying types are\n      // compatible\n      (isNonNullType(newType) &&\n        isChangeSafeForInputObjectFieldOrFieldArg(\n          oldType.ofType,\n          newType.ofType,\n        )) || // moving from non-null to nullable of the same underlying type is safe\n      (!isNonNullType(newType) &&\n        isChangeSafeForInputObjectFieldOrFieldArg(oldType.ofType, newType))\n    );\n  } // if they're both named types, see if their names are equivalent\n\n  return isNamedType(newType) && oldType.name === newType.name;\n}\n\nfunction typeKindName(type) {\n  if (isScalarType(type)) {\n    return 'a Scalar type';\n  }\n\n  if (isObjectType(type)) {\n    return 'an Object type';\n  }\n\n  if (isInterfaceType(type)) {\n    return 'an Interface type';\n  }\n\n  if (isUnionType(type)) {\n    return 'a Union type';\n  }\n\n  if (isEnumType(type)) {\n    return 'an Enum type';\n  }\n\n  if (isInputObjectType(type)) {\n    return 'an Input type';\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible types have been considered.\n\n  false || invariant(false, 'Unexpected type: ' + inspect(type));\n}\n\nfunction stringifyValue(value, type) {\n  const ast = astFromValue(value, type);\n  ast != null || invariant(false);\n  return print(sortValueNode(ast));\n}\n\nfunction diff(oldArray, newArray) {\n  const added = [];\n  const removed = [];\n  const persisted = [];\n  const oldMap = keyMap(oldArray, ({ name }) => name);\n  const newMap = keyMap(newArray, ({ name }) => name);\n\n  for (const oldItem of oldArray) {\n    const newItem = newMap[oldItem.name];\n\n    if (newItem === undefined) {\n      removed.push(oldItem);\n    } else {\n      persisted.push([oldItem, newItem]);\n    }\n  }\n\n  for (const newItem of newArray) {\n    if (oldMap[newItem.name] === undefined) {\n      added.push(newItem);\n    }\n  }\n\n  return {\n    added,\n    persisted,\n    removed,\n  };\n}\n"],"names":["BreakingChangeType","DangerousChangeType","isRequiredArgument","isSpecifiedScalarType","isEnumType","isUnionType","isInputObjectType","isObjectType","isInterfaceType","isRequiredInputField","isListType","isNonNullType","isNamedType","isScalarType","invariant","inspect","astFromValue","print","sortValueNode","keyMap"],"mappings":"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"}