@graphitation/supermassive 2.6.0 → 3.0.0-alpha.1

package/lib/benchmarks/swapi-schema/makeExecutableSchema.js

@@ -0,0 +1,916 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getOwnPropSymbols = Object.getOwnPropertySymbols;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __propIsEnum = Object.prototype.propertyIsEnumerable;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __spreadValues = (a, b) => {
+  for (var prop in b || (b = {}))
+    if (__hasOwnProp.call(b, prop))
+      __defNormalProp(a, prop, b[prop]);
+  if (__getOwnPropSymbols)
+    for (var prop of __getOwnPropSymbols(b)) {
+      if (__propIsEnum.call(b, prop))
+        __defNormalProp(a, prop, b[prop]);
+    }
+  return a;
+};
+var __spreadProps = (a, b) => __defProps(a, __getOwnPropDescs(b));
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var makeExecutableSchema_exports = {};
+__export(makeExecutableSchema_exports, {
+  makeExecutableSchema: () => makeExecutableSchema
+});
+module.exports = __toCommonJS(makeExecutableSchema_exports);
+var import_graphql = require("graphql");
+const makeExecutableSchema = ({
+  typeDefs,
+  resolvers
+}) => {
+  const schema = (0, import_graphql.buildASTSchema)(typeDefs);
+  return createNewSchemaWithResolvers(schema, resolvers);
+};
+const createNewSchemaWithResolvers = (schema, resolvers) => {
+  schema = mapSchema(schema, {
+    ["MapperKind.SCALAR_TYPE" /* SCALAR_TYPE */]: (type) => {
+      var _a, _b, _c, _d, _e, _f;
+      const config = type.toConfig();
+      const resolverValue = resolvers[type.name];
+      if (!(0, import_graphql.isSpecifiedScalarType)(type) && resolverValue != null) {
+        for (const fieldName in resolverValue) {
+          if (fieldName.startsWith("__")) {
+            config[fieldName.substring(2)] = resolverValue[fieldName];
+          } else if (fieldName === "astNode" && config.astNode != null) {
+            config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+              description: (_b = (_a = resolverValue == null ? void 0 : resolverValue.astNode) == null ? void 0 : _a.description) != null ? _b : config.astNode.description,
+              directives: ((_c = config.astNode.directives) != null ? _c : []).concat(
+                (_e = (_d = resolverValue == null ? void 0 : resolverValue.astNode) == null ? void 0 : _d.directives) != null ? _e : []
+              )
+            });
+          } else if (fieldName === "extensionASTNodes" && config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.concat(
+              (_f = resolverValue == null ? void 0 : resolverValue.extensionASTNodes) != null ? _f : []
+            );
+          } else if (fieldName === "extensions" && config.extensions != null && resolverValue.extensions != null) {
+            config.extensions = Object.assign(
+              /* @__PURE__ */ Object.create(null),
+              type.extensions,
+              resolverValue.extensions
+            );
+          } else {
+            config[fieldName] = resolverValue[fieldName];
+          }
+        }
+        return new import_graphql.GraphQLScalarType(config);
+      }
+    },
+    ["MapperKind.ENUM_TYPE" /* ENUM_TYPE */]: (type) => {
+      var _a, _b, _c, _d, _e, _f;
+      const resolverValue = resolvers[type.name];
+      const config = type.toConfig();
+      const enumValueConfigMap = config.values;
+      if (resolverValue != null) {
+        for (const fieldName in resolverValue) {
+          if (fieldName.startsWith("__")) {
+            config[fieldName.substring(2)] = resolverValue[fieldName];
+          } else if (fieldName === "astNode" && config.astNode != null) {
+            config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+              description: (_b = (_a = resolverValue == null ? void 0 : resolverValue.astNode) == null ? void 0 : _a.description) != null ? _b : config.astNode.description,
+              directives: ((_c = config.astNode.directives) != null ? _c : []).concat(
+                (_e = (_d = resolverValue == null ? void 0 : resolverValue.astNode) == null ? void 0 : _d.directives) != null ? _e : []
+              )
+            });
+          } else if (fieldName === "extensionASTNodes" && config.extensionASTNodes != null) {
+            config.extensionASTNodes = config.extensionASTNodes.concat(
+              (_f = resolverValue == null ? void 0 : resolverValue.extensionASTNodes) != null ? _f : []
+            );
+          } else if (fieldName === "extensions" && config.extensions != null && resolverValue.extensions != null) {
+            config.extensions = Object.assign(
+              /* @__PURE__ */ Object.create(null),
+              type.extensions,
+              resolverValue.extensions
+            );
+          } else if (enumValueConfigMap[fieldName]) {
+            enumValueConfigMap[fieldName].value = resolverValue[fieldName];
+          }
+        }
+        return new import_graphql.GraphQLEnumType(config);
+      }
+    },
+    ["MapperKind.UNION_TYPE" /* UNION_TYPE */]: (type) => {
+      const resolverValue = resolvers[type.name];
+      if (resolverValue != null) {
+        const config = type.toConfig();
+        if (resolverValue["__resolveType"]) {
+          config.resolveType = resolverValue["__resolveType"];
+        }
+        return new import_graphql.GraphQLUnionType(config);
+      }
+    },
+    ["MapperKind.OBJECT_TYPE" /* OBJECT_TYPE */]: (type) => {
+      const resolverValue = resolvers[type.name];
+      if (resolverValue != null) {
+        const config = type.toConfig();
+        if (resolverValue["__isTypeOf"]) {
+          config.isTypeOf = resolverValue["__isTypeOf"];
+        }
+        return new import_graphql.GraphQLObjectType(config);
+      }
+    },
+    ["MapperKind.INTERFACE_TYPE" /* INTERFACE_TYPE */]: (type) => {
+      const resolverValue = resolvers[type.name];
+      if (resolverValue != null) {
+        const config = type.toConfig();
+        if (resolverValue["__resolveType"]) {
+          config.resolveType = resolverValue["__resolveType"];
+        }
+        return new import_graphql.GraphQLInterfaceType(config);
+      }
+    },
+    ["MapperKind.COMPOSITE_FIELD" /* COMPOSITE_FIELD */]: (fieldConfig, fieldName, typeName) => {
+      const resolverValue = resolvers[typeName];
+      if (resolverValue != null) {
+        const fieldResolve = resolverValue[fieldName];
+        if (fieldResolve != null) {
+          const newFieldConfig = __spreadValues({}, fieldConfig);
+          if (typeof fieldResolve === "function") {
+            newFieldConfig.resolve = fieldResolve.bind(resolverValue);
+          } else {
+            setFieldProperties(newFieldConfig, fieldResolve);
+          }
+          return newFieldConfig;
+        }
+      }
+    }
+  });
+  function setFieldProperties(field, propertiesObj) {
+    for (const propertyName in propertiesObj) {
+      field[propertyName] = propertiesObj[propertyName];
+    }
+  }
+  return schema;
+};
+function mapSchema(schema, schemaMapper = {}) {
+  const newTypeMap = mapArguments(
+    mapFields(
+      mapTypes(
+        mapDefaultValues(
+          mapEnumValues(
+            mapTypes(
+              mapDefaultValues(
+                schema.getTypeMap(),
+                schema,
+                serializeInputValue
+              ),
+              schema,
+              schemaMapper,
+              (type) => (0, import_graphql.isLeafType)(type)
+            ),
+            schema,
+            schemaMapper
+          ),
+          schema,
+          parseInputValue
+        ),
+        schema,
+        schemaMapper,
+        (type) => !(0, import_graphql.isLeafType)(type)
+      ),
+      schema,
+      schemaMapper
+    ),
+    schema,
+    schemaMapper
+  );
+  const originalDirectives = schema.getDirectives();
+  const newDirectives = mapDirectives(originalDirectives, schema, schemaMapper);
+  const { typeMap, directives } = rewireTypes(newTypeMap, newDirectives);
+  return new import_graphql.GraphQLSchema(__spreadProps(__spreadValues({}, schema.toConfig()), {
+    query: getObjectTypeFromTypeMap(
+      typeMap,
+      getObjectTypeFromTypeMap(newTypeMap, schema.getQueryType())
+    ),
+    mutation: getObjectTypeFromTypeMap(
+      typeMap,
+      getObjectTypeFromTypeMap(newTypeMap, schema.getMutationType())
+    ),
+    subscription: getObjectTypeFromTypeMap(
+      typeMap,
+      getObjectTypeFromTypeMap(newTypeMap, schema.getSubscriptionType())
+    ),
+    types: Object.values(typeMap),
+    directives
+  }));
+}
+function mapTypes(originalTypeMap, schema, schemaMapper, testFn = () => true) {
+  const newTypeMap = {};
+  for (const typeName in originalTypeMap) {
+    if (!typeName.startsWith("__")) {
+      const originalType = originalTypeMap[typeName];
+      if (originalType == null || !testFn(originalType)) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const typeMapper = getTypeMapper(schema, schemaMapper, typeName);
+      if (typeMapper == null) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const maybeNewType = typeMapper(originalType, schema);
+      if (maybeNewType === void 0) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      newTypeMap[typeName] = maybeNewType;
+    }
+  }
+  return newTypeMap;
+}
+function mapEnumValues(originalTypeMap, schema, schemaMapper) {
+  const enumValueMapper = getEnumValueMapper(schemaMapper);
+  if (!enumValueMapper) {
+    return originalTypeMap;
+  }
+  return mapTypes(
+    originalTypeMap,
+    schema,
+    {
+      ["MapperKind.ENUM_TYPE" /* ENUM_TYPE */]: (type) => {
+        const config = type.toConfig();
+        const originalEnumValueConfigMap = config.values;
+        const newEnumValueConfigMap = {};
+        for (const externalValue in originalEnumValueConfigMap) {
+          const originalEnumValueConfig = originalEnumValueConfigMap[externalValue];
+          const mappedEnumValue = enumValueMapper(
+            originalEnumValueConfig,
+            type.name,
+            schema,
+            externalValue
+          );
+          if (mappedEnumValue === void 0) {
+            newEnumValueConfigMap[externalValue] = originalEnumValueConfig;
+          } else if (Array.isArray(mappedEnumValue)) {
+            const [newExternalValue, newEnumValueConfig] = mappedEnumValue;
+            newEnumValueConfigMap[newExternalValue] = newEnumValueConfig === void 0 ? originalEnumValueConfig : newEnumValueConfig;
+          } else if (mappedEnumValue !== null) {
+            newEnumValueConfigMap[externalValue] = mappedEnumValue;
+          }
+        }
+        return correctASTNodes(
+          new import_graphql.GraphQLEnumType(__spreadProps(__spreadValues({}, config), {
+            values: newEnumValueConfigMap
+          }))
+        );
+      }
+    },
+    (type) => (0, import_graphql.isEnumType)(type)
+  );
+}
+function mapDefaultValues(originalTypeMap, schema, fn) {
+  const newTypeMap = mapArguments(originalTypeMap, schema, {
+    ["MapperKind.ARGUMENT" /* ARGUMENT */]: (argumentConfig) => {
+      if (argumentConfig.defaultValue === void 0) {
+        return argumentConfig;
+      }
+      const maybeNewType = getNewType(originalTypeMap, argumentConfig.type);
+      if (maybeNewType != null) {
+        return __spreadProps(__spreadValues({}, argumentConfig), {
+          defaultValue: fn(maybeNewType, argumentConfig.defaultValue)
+        });
+      }
+    }
+  });
+  return mapFields(newTypeMap, schema, {
+    ["MapperKind.INPUT_OBJECT_FIELD" /* INPUT_OBJECT_FIELD */]: (inputFieldConfig) => {
+      if (inputFieldConfig.defaultValue === void 0) {
+        return inputFieldConfig;
+      }
+      const maybeNewType = getNewType(newTypeMap, inputFieldConfig.type);
+      if (maybeNewType != null) {
+        return __spreadProps(__spreadValues({}, inputFieldConfig), {
+          defaultValue: fn(maybeNewType, inputFieldConfig.defaultValue)
+        });
+      }
+    }
+  });
+}
+function getNewType(newTypeMap, type) {
+  if ((0, import_graphql.isListType)(type)) {
+    const newType = getNewType(newTypeMap, type.ofType);
+    return newType != null ? new import_graphql.GraphQLList(newType) : null;
+  } else if ((0, import_graphql.isNonNullType)(type)) {
+    const newType = getNewType(newTypeMap, type.ofType);
+    return newType != null ? new import_graphql.GraphQLNonNull(newType) : null;
+  } else if ((0, import_graphql.isNamedType)(type)) {
+    const newType = newTypeMap[type.name];
+    return newType != null ? newType : null;
+  }
+  return null;
+}
+function mapFields(originalTypeMap, schema, schemaMapper) {
+  const newTypeMap = {};
+  for (const typeName in originalTypeMap) {
+    if (!typeName.startsWith("__")) {
+      const originalType = originalTypeMap[typeName];
+      if (!(0, import_graphql.isObjectType)(originalType) && !(0, import_graphql.isInterfaceType)(originalType) && !(0, import_graphql.isInputObjectType)(originalType)) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const fieldMapper = getFieldMapper(schema, schemaMapper, typeName);
+      if (fieldMapper == null) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const config = originalType.toConfig();
+      const originalFieldConfigMap = config.fields;
+      const newFieldConfigMap = {};
+      for (const fieldName in originalFieldConfigMap) {
+        const originalFieldConfig = originalFieldConfigMap[fieldName];
+        const mappedField = fieldMapper(
+          originalFieldConfig,
+          fieldName,
+          typeName,
+          schema
+        );
+        if (mappedField === void 0) {
+          newFieldConfigMap[fieldName] = originalFieldConfig;
+        } else if (Array.isArray(mappedField)) {
+          const [newFieldName, newFieldConfig] = mappedField;
+          if (newFieldConfig.astNode != null) {
+            newFieldConfig.astNode = __spreadProps(__spreadValues({}, newFieldConfig.astNode), {
+              name: __spreadProps(__spreadValues({}, newFieldConfig.astNode.name), {
+                value: newFieldName
+              })
+            });
+          }
+          newFieldConfigMap[newFieldName] = newFieldConfig === void 0 ? originalFieldConfig : newFieldConfig;
+        } else if (mappedField !== null) {
+          newFieldConfigMap[fieldName] = mappedField;
+        }
+      }
+      if ((0, import_graphql.isObjectType)(originalType)) {
+        newTypeMap[typeName] = correctASTNodes(
+          new import_graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), {
+            fields: newFieldConfigMap
+          }))
+        );
+      } else if ((0, import_graphql.isInterfaceType)(originalType)) {
+        newTypeMap[typeName] = correctASTNodes(
+          new import_graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, config), {
+            fields: newFieldConfigMap
+          }))
+        );
+      } else {
+        newTypeMap[typeName] = correctASTNodes(
+          new import_graphql.GraphQLInputObjectType(__spreadProps(__spreadValues({}, config), {
+            fields: newFieldConfigMap
+          }))
+        );
+      }
+    }
+  }
+  return newTypeMap;
+}
+function mapArguments(originalTypeMap, schema, schemaMapper) {
+  const newTypeMap = {};
+  for (const typeName in originalTypeMap) {
+    if (!typeName.startsWith("__")) {
+      const originalType = originalTypeMap[typeName];
+      if (!(0, import_graphql.isObjectType)(originalType) && !(0, import_graphql.isInterfaceType)(originalType)) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const argumentMapper = getArgumentMapper(schemaMapper);
+      if (argumentMapper == null) {
+        newTypeMap[typeName] = originalType;
+        continue;
+      }
+      const config = originalType.toConfig();
+      const originalFieldConfigMap = config.fields;
+      const newFieldConfigMap = {};
+      for (const fieldName in originalFieldConfigMap) {
+        const originalFieldConfig = originalFieldConfigMap[fieldName];
+        const originalArgumentConfigMap = originalFieldConfig.args;
+        if (originalArgumentConfigMap == null) {
+          newFieldConfigMap[fieldName] = originalFieldConfig;
+          continue;
+        }
+        const argumentNames = Object.keys(originalArgumentConfigMap);
+        if (!argumentNames.length) {
+          newFieldConfigMap[fieldName] = originalFieldConfig;
+          continue;
+        }
+        const newArgumentConfigMap = {};
+        for (const argumentName of argumentNames) {
+          const originalArgumentConfig = originalArgumentConfigMap[argumentName];
+          const mappedArgument = argumentMapper(
+            originalArgumentConfig,
+            fieldName,
+            typeName,
+            schema
+          );
+          if (mappedArgument === void 0) {
+            newArgumentConfigMap[argumentName] = originalArgumentConfig;
+          } else if (Array.isArray(mappedArgument)) {
+            const [newArgumentName, newArgumentConfig] = mappedArgument;
+            newArgumentConfigMap[newArgumentName] = newArgumentConfig;
+          } else if (mappedArgument !== null) {
+            newArgumentConfigMap[argumentName] = mappedArgument;
+          }
+        }
+        newFieldConfigMap[fieldName] = __spreadProps(__spreadValues({}, originalFieldConfig), {
+          args: newArgumentConfigMap
+        });
+      }
+      if ((0, import_graphql.isObjectType)(originalType)) {
+        newTypeMap[typeName] = new import_graphql.GraphQLObjectType(__spreadProps(__spreadValues({}, config), {
+          fields: newFieldConfigMap
+        }));
+      } else if ((0, import_graphql.isInterfaceType)(originalType)) {
+        newTypeMap[typeName] = new import_graphql.GraphQLInterfaceType(__spreadProps(__spreadValues({}, config), {
+          fields: newFieldConfigMap
+        }));
+      } else {
+        newTypeMap[typeName] = new import_graphql.GraphQLInputObjectType(__spreadProps(__spreadValues({}, config), {
+          fields: newFieldConfigMap
+        }));
+      }
+    }
+  }
+  return newTypeMap;
+}
+function mapDirectives(originalDirectives, schema, schemaMapper) {
+  const directiveMapper = getDirectiveMapper(schemaMapper);
+  if (directiveMapper == null) {
+    return originalDirectives.slice();
+  }
+  const newDirectives = [];
+  for (const directive of originalDirectives) {
+    const mappedDirective = directiveMapper(directive, schema);
+    if (mappedDirective === void 0) {
+      newDirectives.push(directive);
+    } else if (mappedDirective !== null) {
+      newDirectives.push(mappedDirective);
+    }
+  }
+  return newDirectives;
+}
+function getTypeSpecifiers(schema, typeName) {
+  var _a, _b, _c;
+  const type = schema.getType(typeName);
+  const specifiers = ["MapperKind.TYPE" /* TYPE */];
+  if ((0, import_graphql.isObjectType)(type)) {
+    specifiers.push("MapperKind.COMPOSITE_TYPE" /* COMPOSITE_TYPE */, "MapperKind.OBJECT_TYPE" /* OBJECT_TYPE */);
+    if (typeName === ((_a = schema.getQueryType()) == null ? void 0 : _a.name)) {
+      specifiers.push("MapperKind.ROOT_OBJECT" /* ROOT_OBJECT */, "MapperKind.QUERY" /* QUERY */);
+    } else if (typeName === ((_b = schema.getMutationType()) == null ? void 0 : _b.name)) {
+      specifiers.push("MapperKind.ROOT_OBJECT" /* ROOT_OBJECT */, "MapperKind.MUTATION" /* MUTATION */);
+    } else if (typeName === ((_c = schema.getSubscriptionType()) == null ? void 0 : _c.name)) {
+      specifiers.push("MapperKind.ROOT_OBJECT" /* ROOT_OBJECT */, "MapperKind.SUBSCRIPTION" /* SUBSCRIPTION */);
+    }
+  } else if ((0, import_graphql.isInputObjectType)(type)) {
+    specifiers.push("MapperKind.INPUT_OBJECT_TYPE" /* INPUT_OBJECT_TYPE */);
+  } else if ((0, import_graphql.isInterfaceType)(type)) {
+    specifiers.push(
+      "MapperKind.COMPOSITE_TYPE" /* COMPOSITE_TYPE */,
+      "MapperKind.ABSTRACT_TYPE" /* ABSTRACT_TYPE */,
+      "MapperKind.INTERFACE_TYPE" /* INTERFACE_TYPE */
+    );
+  } else if ((0, import_graphql.isUnionType)(type)) {
+    specifiers.push(
+      "MapperKind.COMPOSITE_TYPE" /* COMPOSITE_TYPE */,
+      "MapperKind.ABSTRACT_TYPE" /* ABSTRACT_TYPE */,
+      "MapperKind.UNION_TYPE" /* UNION_TYPE */
+    );
+  } else if ((0, import_graphql.isEnumType)(type)) {
+    specifiers.push("MapperKind.ENUM_TYPE" /* ENUM_TYPE */);
+  } else if ((0, import_graphql.isScalarType)(type)) {
+    specifiers.push("MapperKind.SCALAR_TYPE" /* SCALAR_TYPE */);
+  }
+  return specifiers;
+}
+function getTypeMapper(schema, schemaMapper, typeName) {
+  const specifiers = getTypeSpecifiers(schema, typeName);
+  let typeMapper;
+  const stack = [...specifiers];
+  while (!typeMapper && stack.length > 0) {
+    const next = stack.pop();
+    typeMapper = schemaMapper[next];
+  }
+  return typeMapper != null ? typeMapper : null;
+}
+function getFieldSpecifiers(schema, typeName) {
+  var _a, _b, _c;
+  const type = schema.getType(typeName);
+  const specifiers = ["MapperKind.FIELD" /* FIELD */];
+  if ((0, import_graphql.isObjectType)(type)) {
+    specifiers.push("MapperKind.COMPOSITE_FIELD" /* COMPOSITE_FIELD */, "MapperKind.OBJECT_FIELD" /* OBJECT_FIELD */);
+    if (typeName === ((_a = schema.getQueryType()) == null ? void 0 : _a.name)) {
+      specifiers.push("MapperKind.ROOT_FIELD" /* ROOT_FIELD */, "MapperKind.QUERY_ROOT_FIELD" /* QUERY_ROOT_FIELD */);
+    } else if (typeName === ((_b = schema.getMutationType()) == null ? void 0 : _b.name)) {
+      specifiers.push("MapperKind.ROOT_FIELD" /* ROOT_FIELD */, "MapperKind.MUTATION_ROOT_FIELD" /* MUTATION_ROOT_FIELD */);
+    } else if (typeName === ((_c = schema.getSubscriptionType()) == null ? void 0 : _c.name)) {
+      specifiers.push(
+        "MapperKind.ROOT_FIELD" /* ROOT_FIELD */,
+        "MapperKind.SUBSCRIPTION_ROOT_FIELD" /* SUBSCRIPTION_ROOT_FIELD */
+      );
+    }
+  } else if ((0, import_graphql.isInterfaceType)(type)) {
+    specifiers.push("MapperKind.COMPOSITE_FIELD" /* COMPOSITE_FIELD */, "MapperKind.INTERFACE_FIELD" /* INTERFACE_FIELD */);
+  } else if ((0, import_graphql.isInputObjectType)(type)) {
+    specifiers.push("MapperKind.INPUT_OBJECT_FIELD" /* INPUT_OBJECT_FIELD */);
+  }
+  return specifiers;
+}
+function getFieldMapper(schema, schemaMapper, typeName) {
+  const specifiers = getFieldSpecifiers(schema, typeName);
+  let fieldMapper;
+  const stack = [...specifiers];
+  while (!fieldMapper && stack.length > 0) {
+    const next = stack.pop();
+    fieldMapper = schemaMapper[next];
+  }
+  return fieldMapper != null ? fieldMapper : null;
+}
+function getArgumentMapper(schemaMapper) {
+  const argumentMapper = schemaMapper["MapperKind.ARGUMENT" /* ARGUMENT */];
+  return argumentMapper != null ? argumentMapper : null;
+}
+function getDirectiveMapper(schemaMapper) {
+  const directiveMapper = schemaMapper["MapperKind.DIRECTIVE" /* DIRECTIVE */];
+  return directiveMapper != null ? directiveMapper : null;
+}
+function getEnumValueMapper(schemaMapper) {
+  const enumValueMapper = schemaMapper["MapperKind.ENUM_VALUE" /* ENUM_VALUE */];
+  return enumValueMapper != null ? enumValueMapper : null;
+}
+function correctASTNodes(type) {
+  if ((0, import_graphql.isObjectType)(type)) {
+    const config = type.toConfig();
+    if (config.astNode != null) {
+      const fields = [];
+      for (const fieldName in config.fields) {
+        const fieldConfig = config.fields[fieldName];
+        if (fieldConfig.astNode != null) {
+          fields.push(fieldConfig.astNode);
+        }
+      }
+      config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+        kind: import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+        fields
+      });
+    }
+    if (config.extensionASTNodes != null) {
+      config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), {
+        kind: import_graphql.Kind.OBJECT_TYPE_EXTENSION,
+        fields: void 0
+      }));
+    }
+    return new import_graphql.GraphQLObjectType(config);
+  } else if ((0, import_graphql.isInterfaceType)(type)) {
+    const config = type.toConfig();
+    if (config.astNode != null) {
+      const fields = [];
+      for (const fieldName in config.fields) {
+        const fieldConfig = config.fields[fieldName];
+        if (fieldConfig.astNode != null) {
+          fields.push(fieldConfig.astNode);
+        }
+      }
+      config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+        kind: import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+        fields
+      });
+    }
+    if (config.extensionASTNodes != null) {
+      config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), {
+        kind: import_graphql.Kind.INTERFACE_TYPE_EXTENSION,
+        fields: void 0
+      }));
+    }
+    return new import_graphql.GraphQLInterfaceType(config);
+  } else if ((0, import_graphql.isInputObjectType)(type)) {
+    const config = type.toConfig();
+    if (config.astNode != null) {
+      const fields = [];
+      for (const fieldName in config.fields) {
+        const fieldConfig = config.fields[fieldName];
+        if (fieldConfig.astNode != null) {
+          fields.push(fieldConfig.astNode);
+        }
+      }
+      config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+        kind: import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+        fields
+      });
+    }
+    if (config.extensionASTNodes != null) {
+      config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), {
+        kind: import_graphql.Kind.INPUT_OBJECT_TYPE_EXTENSION,
+        fields: void 0
+      }));
+    }
+    return new import_graphql.GraphQLInputObjectType(config);
+  } else if ((0, import_graphql.isEnumType)(type)) {
+    const config = type.toConfig();
+    if (config.astNode != null) {
+      const values = [];
+      for (const enumKey in config.values) {
+        const enumValueConfig = config.values[enumKey];
+        if (enumValueConfig.astNode != null) {
+          values.push(enumValueConfig.astNode);
+        }
+      }
+      config.astNode = __spreadProps(__spreadValues({}, config.astNode), {
+        values
+      });
+    }
+    if (config.extensionASTNodes != null) {
+      config.extensionASTNodes = config.extensionASTNodes.map((node) => __spreadProps(__spreadValues({}, node), {
+        values: void 0
+      }));
+    }
+    return new import_graphql.GraphQLEnumType(config);
+  } else {
+    return type;
+  }
+}
+function getObjectTypeFromTypeMap(typeMap, type) {
+  if (type) {
+    const maybeObjectType = typeMap[type.name];
+    if ((0, import_graphql.isObjectType)(maybeObjectType)) {
+      return maybeObjectType;
+    }
+  }
+}
+var MapperKind = /* @__PURE__ */ ((MapperKind2) => {
+  MapperKind2["TYPE"] = "MapperKind.TYPE";
+  MapperKind2["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE";
+  MapperKind2["ENUM_TYPE"] = "MapperKind.ENUM_TYPE";
+  MapperKind2["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE";
+  MapperKind2["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE";
+  MapperKind2["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE";
+  MapperKind2["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE";
+  MapperKind2["UNION_TYPE"] = "MapperKind.UNION_TYPE";
+  MapperKind2["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE";
+  MapperKind2["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT";
+  MapperKind2["QUERY"] = "MapperKind.QUERY";
+  MapperKind2["MUTATION"] = "MapperKind.MUTATION";
+  MapperKind2["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION";
+  MapperKind2["DIRECTIVE"] = "MapperKind.DIRECTIVE";
+  MapperKind2["FIELD"] = "MapperKind.FIELD";
+  MapperKind2["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD";
+  MapperKind2["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD";
+  MapperKind2["ROOT_FIELD"] = "MapperKind.ROOT_FIELD";
+  MapperKind2["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD";
+  MapperKind2["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD";
+  MapperKind2["SUBSCRIPTION_ROOT_FIELD"] = "MapperKind.SUBSCRIPTION_ROOT_FIELD";
+  MapperKind2["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD";
+  MapperKind2["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD";
+  MapperKind2["ARGUMENT"] = "MapperKind.ARGUMENT";
+  MapperKind2["ENUM_VALUE"] = "MapperKind.ENUM_VALUE";
+  return MapperKind2;
+})(MapperKind || {});
+function rewireTypes(originalTypeMap, directives) {
+  const referenceTypeMap = /* @__PURE__ */ Object.create(null);
+  for (const typeName in originalTypeMap) {
+    referenceTypeMap[typeName] = originalTypeMap[typeName];
+  }
+  const newTypeMap = /* @__PURE__ */ Object.create(null);
+  for (const typeName in referenceTypeMap) {
+    const namedType = referenceTypeMap[typeName];
+    if (namedType == null || typeName.startsWith("__")) {
+      continue;
+    }
+    const newName = namedType.name;
+    if (newName.startsWith("__")) {
+      continue;
+    }
+    if (newTypeMap[newName] != null) {
+      console.warn(
+        `Duplicate schema type name ${newName} found; keeping the existing one found in the schema`
+      );
+      continue;
+    }
+    newTypeMap[newName] = namedType;
+  }
+  for (const typeName in newTypeMap) {
+    newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
+  }
+  const newDirectives = directives.map(
+    (directive) => rewireDirective(directive)
+  );
+  return {
+    typeMap: newTypeMap,
+    directives: newDirectives
+  };
+  function rewireDirective(directive) {
+    if ((0, import_graphql.isSpecifiedDirective)(directive)) {
+      return directive;
+    }
+    const directiveConfig = directive.toConfig();
+    directiveConfig.args = rewireArgs(directiveConfig.args);
+    return new import_graphql.GraphQLDirective(directiveConfig);
+  }
+  function rewireArgs(args) {
+    const rewiredArgs = {};
+    for (const argName in args) {
+      const arg = args[argName];
+      const rewiredArgType = rewireType(arg.type);
+      if (rewiredArgType != null) {
+        arg.type = rewiredArgType;
+        rewiredArgs[argName] = arg;
+      }
+    }
+    return rewiredArgs;
+  }
+  function rewireNamedType(type) {
+    if ((0, import_graphql.isObjectType)(type)) {
+      const config = type.toConfig();
+      const newConfig = __spreadProps(__spreadValues({}, config), {
+        fields: () => rewireFields(config.fields),
+        interfaces: () => rewireNamedTypes(config.interfaces)
+      });
+      return new import_graphql.GraphQLObjectType(newConfig);
+    } else if ((0, import_graphql.isInterfaceType)(type)) {
+      const config = type.toConfig();
+      const newConfig = __spreadProps(__spreadValues({}, config), {
+        fields: () => rewireFields(config.fields)
+      });
+      if ("interfaces" in newConfig) {
+        newConfig.interfaces = () => rewireNamedTypes(
+          config.interfaces
+        );
+      }
+      return new import_graphql.GraphQLInterfaceType(newConfig);
+    } else if ((0, import_graphql.isUnionType)(type)) {
+      const config = type.toConfig();
+      const newConfig = __spreadProps(__spreadValues({}, config), {
+        types: () => rewireNamedTypes(config.types)
+      });
+      return new import_graphql.GraphQLUnionType(newConfig);
+    } else if ((0, import_graphql.isInputObjectType)(type)) {
+      const config = type.toConfig();
+      const newConfig = __spreadProps(__spreadValues({}, config), {
+        fields: () => rewireInputFields(config.fields)
+      });
+      return new import_graphql.GraphQLInputObjectType(newConfig);
+    } else if ((0, import_graphql.isEnumType)(type)) {
+      const enumConfig = type.toConfig();
+      return new import_graphql.GraphQLEnumType(enumConfig);
+    } else if ((0, import_graphql.isScalarType)(type)) {
+      if ((0, import_graphql.isSpecifiedScalarType)(type)) {
+        return type;
+      }
+      const scalarConfig = type.toConfig();
+      return new import_graphql.GraphQLScalarType(scalarConfig);
+    }
+    throw new Error(`Unexpected schema type: ${type}`);
+  }
+  function rewireFields(fields) {
+    const rewiredFields = {};
+    for (const fieldName in fields) {
+      const field = fields[fieldName];
+      const rewiredFieldType = rewireType(field.type);
+      if (rewiredFieldType != null && field.args) {
+        field.type = rewiredFieldType;
+        field.args = rewireArgs(field.args);
+        rewiredFields[fieldName] = field;
+      }
+    }
+    return rewiredFields;
+  }
+  function rewireInputFields(fields) {
+    const rewiredFields = {};
+    for (const fieldName in fields) {
+      const field = fields[fieldName];
+      const rewiredFieldType = rewireType(field.type);
+      if (rewiredFieldType != null) {
+        field.type = rewiredFieldType;
+        rewiredFields[fieldName] = field;
+      }
+    }
+    return rewiredFields;
+  }
+  function rewireNamedTypes(namedTypes) {
+    const rewiredTypes = [];
+    for (const namedType of namedTypes) {
+      const rewiredType = rewireType(namedType);
+      if (rewiredType != null) {
+        rewiredTypes.push(rewiredType);
+      }
+    }
+    return rewiredTypes;
+  }
+  function rewireType(type) {
+    if ((0, import_graphql.isListType)(type)) {
+      const rewiredType = rewireType(type.ofType);
+      return rewiredType != null ? new import_graphql.GraphQLList(rewiredType) : null;
+    } else if ((0, import_graphql.isNonNullType)(type)) {
+      const rewiredType = rewireType(type.ofType);
+      return rewiredType != null ? new import_graphql.GraphQLNonNull(rewiredType) : null;
+    } else if ((0, import_graphql.isNamedType)(type)) {
+      let rewiredType = referenceTypeMap[type.name];
+      if (rewiredType === void 0) {
+        rewiredType = isNamedStub(type) ? getBuiltInForStub(type) : rewireNamedType(type);
+        newTypeMap[rewiredType.name] = referenceTypeMap[type.name] = rewiredType;
+      }
+      return rewiredType != null ? newTypeMap[rewiredType.name] : null;
+    }
+    return null;
+  }
+}
+function isNamedStub(type) {
+  if ("getFields" in type) {
+    const fields = type.getFields();
+    for (const fieldName in fields) {
+      const field = fields[fieldName];
+      return field.name === "_fake";
+    }
+  }
+  return false;
+}
+function getBuiltInForStub(type) {
+  switch (type.name) {
+    case import_graphql.GraphQLInt.name:
+      return import_graphql.GraphQLInt;
+    case import_graphql.GraphQLFloat.name:
+      return import_graphql.GraphQLFloat;
+    case import_graphql.GraphQLString.name:
+      return import_graphql.GraphQLString;
+    case import_graphql.GraphQLBoolean.name:
+      return import_graphql.GraphQLBoolean;
+    case import_graphql.GraphQLID.name:
+      return import_graphql.GraphQLID;
+    default:
+      return type;
+  }
+}
+function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) {
+  if (value == null) {
+    return value;
+  }
+  const nullableType = (0, import_graphql.getNullableType)(type);
+  if ((0, import_graphql.isLeafType)(nullableType)) {
+    return inputLeafValueTransformer != null ? inputLeafValueTransformer(nullableType, value) : value;
+  } else if ((0, import_graphql.isListType)(nullableType)) {
+    return asArray(value).map(
+      (listMember) => transformInputValue(
+        nullableType.ofType,
+        listMember,
+        inputLeafValueTransformer,
+        inputObjectValueTransformer
+      )
+    );
+  } else if ((0, import_graphql.isInputObjectType)(nullableType)) {
+    const fields = nullableType.getFields();
+    const newValue = {};
+    for (const key in value) {
+      const field = fields[key];
+      if (field != null) {
+        newValue[key] = transformInputValue(
+          field.type,
+          value[key],
+          inputLeafValueTransformer,
+          inputObjectValueTransformer
+        );
+      }
+    }
+    return inputObjectValueTransformer != null ? inputObjectValueTransformer(nullableType, newValue) : newValue;
+  }
+}
+function serializeInputValue(type, value) {
+  return transformInputValue(type, value, (t, v) => {
+    try {
+      return t.serialize(v);
+    } catch (e) {
+      return v;
+    }
+  });
+}
+function parseInputValue(type, value) {
+  return transformInputValue(type, value, (t, v) => {
+    try {
+      return t.parseValue(v);
+    } catch (e) {
+      return v;
+    }
+  });
+}
+const asArray = (fns) => Array.isArray(fns) ? fns : fns ? [fns] : [];