@graphitation/supermassive 2.6.1 → 3.0.0-alpha.3

package/lib/utilities/addMinimalViableSchemaToRequestDocument.mjs

@@ -0,0 +1,317 @@
+var __defProp = Object.defineProperty;
+var __defProps = Object.defineProperties;
+var __getOwnPropDescs = Object.getOwnPropertyDescriptors;
+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));
+
+// src/utilities/addMinimalViableSchemaToRequestDocument.ts
+import {
+  GraphQLError,
+  isCompositeType,
+  isEnumType,
+  isInputObjectType,
+  isNonNullType,
+  isObjectType,
+  isScalarType,
+  isSpecifiedScalarType,
+  isUnionType,
+  Kind,
+  TypeInfo,
+  visit,
+  visitWithTypeInfo
+} from "graphql";
+import {
+  DirectiveKeys,
+  FieldKeys,
+  InputObjectKeys,
+  InputValueKeys,
+  InterfaceKeys,
+  ObjectKeys,
+  TypeKind
+} from "../schema/definition.mjs";
+import {
+  inspectTypeReference,
+  typeNameFromReference,
+  typeReferenceFromName
+} from "../schema/reference.mjs";
+import { invariant } from "../jsutils/invariant.mjs";
+import {
+  isSpecifiedDirective,
+  SUPERMASSIVE_SCHEMA_DIRECTIVE_FRAGMENT_ARGUMENT_NAME,
+  SUPERMASSIVE_SCHEMA_DIRECTIVE_NAME
+} from "../schema/directives.mjs";
+import { makeReadableErrorPath } from "./makeReadableErrorPath.mjs";
+function addMinimalViableSchemaToRequestDocument(schema, document, options) {
+  return __spreadProps(__spreadValues({}, document), {
+    definitions: document.definitions.map(
+      (node) => node.kind === Kind.OPERATION_DEFINITION || node.kind === Kind.FRAGMENT_DEFINITION ? addMinimalViableSchemaToExecutableDefinitionNode(
+        schema,
+        node,
+        options
+      ) : node
+    )
+  });
+}
+function addMinimalViableSchemaToExecutableDefinitionNode(schema, node, options) {
+  var _a, _b;
+  if ((_a = node.directives) == null ? void 0 : _a.some((directive2) => directive2.name.value === "schema")) {
+    return node;
+  }
+  const schemaFragment = extractMinimalViableSchemaForRequestDocument(
+    schema,
+    { kind: Kind.DOCUMENT, definitions: [node] },
+    options
+  );
+  const directive = {
+    kind: Kind.DIRECTIVE,
+    name: nameNode(SUPERMASSIVE_SCHEMA_DIRECTIVE_NAME),
+    arguments: [
+      argNode(
+        SUPERMASSIVE_SCHEMA_DIRECTIVE_FRAGMENT_ARGUMENT_NAME,
+        schemaFragment
+      )
+    ]
+  };
+  return __spreadProps(__spreadValues({}, node), {
+    directives: [...(_b = node.directives) != null ? _b : [], directive]
+  });
+}
+function nameNode(name) {
+  return { kind: Kind.NAME, value: name };
+}
+function argNode(name, value) {
+  return {
+    kind: Kind.ARGUMENT,
+    name: nameNode(name),
+    value: { kind: Kind.STRING, value: JSON.stringify(value) }
+  };
+}
+function extractMinimalViableSchemaForRequestDocument(schema, document, options) {
+  const types = /* @__PURE__ */ Object.create(null);
+  const directives = [];
+  const typeInfo = new TypeInfo(schema);
+  visit(
+    document,
+    visitWithTypeInfo(typeInfo, {
+      Field(node, _key, _parent, _path, ancestors) {
+        const parentType = typeInfo.getParentType();
+        assertCompositeType(parentType, node, ancestors);
+        const typeDef = addCompositeType(types, parentType);
+        if (typeDef[0] === TypeKind.UNION || node.name.value === "__typename") {
+          return;
+        }
+        const field = typeInfo.getFieldDef();
+        assertExistingField(field, node, ancestors);
+        assertAllArgumentsAreDefined(field, node, ancestors);
+        const fieldDef = addField(typeDef, field, node);
+        if (Array.isArray(fieldDef)) {
+          addReferencedOutputType(schema, types, fieldDef[FieldKeys.type]);
+          addReferencedInputTypes(schema, types, fieldDef[FieldKeys.arguments]);
+        } else {
+          addReferencedOutputType(schema, types, fieldDef);
+        }
+      },
+      Directive(node, _key, _parent, _path, ancestors) {
+        var _a;
+        if (isSpecifiedDirective(node.name.value) || ((_a = options == null ? void 0 : options.ignoredDirectives) == null ? void 0 : _a.includes(node.name.value))) {
+          return;
+        }
+        const directive = typeInfo.getDirective();
+        if (!directive) {
+          const errorPath = makeReadableErrorPath(ancestors);
+          throw new GraphQLError(
+            `Cannot find definition for directive: ${errorPath.join(".")} @${node.name.value}`,
+            { nodes: node }
+          );
+        }
+        addDirective(directives, directive, node);
+      },
+      FragmentDefinition(node, _key, _parent, _path, ancestors) {
+        const type = typeInfo.getType();
+        assertCompositeType(type, node, ancestors);
+        addCompositeType(types, type);
+      },
+      InlineFragment(node, _key, _parent, _path, ancestors) {
+        if (node == null ? void 0 : node.typeCondition) {
+          const type = typeInfo.getType();
+          assertCompositeType(type, node, ancestors);
+          addCompositeType(types, type);
+        }
+      },
+      Argument() {
+        return false;
+      }
+    })
+  );
+  return directives.length ? { types, directives } : { types };
+}
+function addReferencedOutputType(schema, types, typeRef) {
+  const name = typeNameFromReference(typeRef);
+  const schemaType = schema.getType(name);
+  if (!schemaType) {
+    throw new Error(`Type ${name} not found in schema`);
+  }
+  if (types[name] || isSpecifiedScalarType(schemaType)) {
+    return;
+  }
+  if (isCompositeType(schemaType)) {
+    addCompositeType(types, schemaType);
+  } else if (isEnumType(schemaType)) {
+    types[name] = encodeEnumType(schemaType);
+  } else if (isScalarType(schemaType)) {
+    types[name] = encodeScalarType(schemaType);
+  } else {
+    invariant(false, "Got non-output type: " + inspectTypeReference(typeRef));
+  }
+}
+function addReferencedInputTypes(schema, types, inputValues) {
+  for (const inputValueDef of Object.values(inputValues)) {
+    const typeRef = Array.isArray(inputValueDef) ? inputValueDef[InputValueKeys.type] : inputValueDef;
+    const name = typeNameFromReference(typeRef);
+    const schemaType = schema.getType(name);
+    if (!schemaType) {
+      throw new Error(`Type ${name} not found in schema`);
+    }
+    if (types[name] || isSpecifiedScalarType(schemaType)) {
+      continue;
+    }
+    if (isInputObjectType(schemaType)) {
+      const inputObjectDef = encodeInputObjectType(schemaType);
+      types[name] = inputObjectDef;
+      addReferencedInputTypes(
+        schema,
+        types,
+        inputObjectDef[InputObjectKeys.fields]
+      );
+    } else if (isEnumType(schemaType)) {
+      types[name] = encodeEnumType(schemaType);
+    } else if (isScalarType(schemaType)) {
+      types[name] = encodeScalarType(schemaType);
+    } else {
+      invariant(false, "Got non-input type: " + inspectTypeReference(typeRef));
+    }
+  }
+}
+function addCompositeType(types, type) {
+  if (types[type.name]) {
+    return types[type.name];
+  }
+  return types[type.name] = encodeCompositeType(type);
+}
+function addField(type, field, fieldNode) {
+  var _a;
+  const fields = type[0] === TypeKind.OBJECT ? type[ObjectKeys.fields] : type[InterfaceKeys.fields];
+  const existingFieldDef = fields[field.name];
+  const previouslyAddedArgs = Array.isArray(existingFieldDef) ? existingFieldDef[FieldKeys.arguments] : /* @__PURE__ */ Object.create(null);
+  const nodeArgs = new Set((_a = fieldNode.arguments) == null ? void 0 : _a.map((arg) => arg.name.value));
+  const argsFilter = (argDef) => Boolean(
+    previouslyAddedArgs[argDef.name] || isNonNullType(argDef.type) || argDef.defaultValue !== void 0 || nodeArgs.has(argDef.name)
+  );
+  return fields[field.name] = encodeFieldDef(field, argsFilter);
+}
+function addDirective(directives, directive, node) {
+  var _a;
+  const name = directive.name;
+  let tuple = directives.find((d) => d[DirectiveKeys.name] === name);
+  if (!tuple) {
+    tuple = [directive.name];
+    directives.push(tuple);
+  }
+  const previouslyAddedArgs = tuple[DirectiveKeys.arguments];
+  const nodeArgs = new Set((_a = node.arguments) == null ? void 0 : _a.map((arg) => arg.name.value));
+  const argsFilter = (argDef) => Boolean(
+    (previouslyAddedArgs == null ? void 0 : previouslyAddedArgs[argDef.name]) || isNonNullType(argDef.type) || argDef.defaultValue !== void 0 || nodeArgs.has(argDef.name)
+  );
+  const [hasArgs, argsRecord] = encodeArguments(directive.args, argsFilter);
+  if (hasArgs) {
+    tuple[DirectiveKeys.arguments] = argsRecord;
+  }
+  return tuple;
+}
+function encodeCompositeType(type) {
+  if (isUnionType(type)) {
+    return [TypeKind.UNION, type.getTypes().map((type2) => type2.name)];
+  }
+  const ifaces = type.getInterfaces().map((iface) => iface.name);
+  const typeKind = isObjectType(type) ? TypeKind.OBJECT : TypeKind.INTERFACE;
+  return ifaces.length ? [typeKind, {}, ifaces] : [typeKind, {}];
+}
+function encodeInputObjectType(type) {
+  const result = /* @__PURE__ */ Object.create(null);
+  for (const [fieldName, field] of Object.entries(type.getFields())) {
+    result[fieldName] = encodeInputField(field);
+  }
+  return [TypeKind.INPUT, result];
+}
+function encodeInputField(field) {
+  const typeReference = typeReferenceFromName(field.type.toString());
+  return field.defaultValue === void 0 ? typeReference : [typeReference, field.defaultValue];
+}
+function encodeFieldDef(field, argumentsFilter) {
+  const typeReference = typeReferenceFromName(field.type.toString());
+  const [hasArgs, argsRecord] = encodeArguments(field.args, argumentsFilter);
+  return !hasArgs ? typeReference : [typeReference, argsRecord];
+}
+function encodeArguments(args, argumentsFilter) {
+  let hasArgs = false;
+  const argsRecord = {};
+  for (const argDef of args) {
+    if (argumentsFilter && !argumentsFilter(argDef)) {
+      continue;
+    }
+    const typeReference = typeReferenceFromName(argDef.type.toString());
+    argsRecord[argDef.name] = argDef.defaultValue === void 0 ? typeReference : [typeReference, argDef.defaultValue];
+    hasArgs = true;
+  }
+  return [hasArgs, argsRecord];
+}
+function encodeEnumType(type) {
+  return [TypeKind.ENUM, type.getValues().map((v) => v.name)];
+}
+function encodeScalarType(_type) {
+  return [TypeKind.SCALAR];
+}
+function assertCompositeType(type, node, ancestors) {
+  if (!type || !isCompositeType(type)) {
+    const path = node.kind === Kind.FIELD ? makeReadableErrorPath(ancestors).join(".") + "." + node.name.value : makeReadableErrorPath(ancestors).join(".");
+    throw new GraphQLError(`Cannot find type for: ${path}`, {
+      nodes: node
+    });
+  }
+}
+function assertExistingField(field, node, ancestors) {
+  if (!field) {
+    const path = makeReadableErrorPath(ancestors).join(".") + "." + node.name.value;
+    throw new GraphQLError(`Cannot find field: ${path}`, { nodes: node });
+  }
+}
+function assertAllArgumentsAreDefined(field, node, ancestors) {
+  var _a;
+  const defArgs = new Set(field.args.map((arg) => arg.name));
+  for (const arg of (_a = node.arguments) != null ? _a : []) {
+    if (!defArgs.has(arg.name.value)) {
+      const path = makeReadableErrorPath(ancestors).join(".") + "." + node.name.value + `(${arg.name.value}: ...)`;
+      throw new GraphQLError(`Cannot find type for argument: ${path}`, {
+        nodes: arg
+      });
+    }
+  }
+}
+export {
+  addMinimalViableSchemaToRequestDocument,
+  extractMinimalViableSchemaForRequestDocument
+};

package/lib/utilities/addMinimalViableSchemaToRequestDocument.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/addMinimalViableSchemaToRequestDocument.ts"],
+  "sourcesContent": ["import {\n  ArgumentNode,\n  ASTNode,\n  DirectiveNode,\n  DocumentNode,\n  ExecutableDefinitionNode,\n  FieldNode,\n  GraphQLArgument,\n  GraphQLCompositeType,\n  GraphQLDirective,\n  GraphQLEnumType,\n  GraphQLError,\n  GraphQLField,\n  GraphQLInputObjectType,\n  GraphQLInputField,\n  GraphQLOutputType,\n  GraphQLScalarType,\n  GraphQLSchema,\n  isCompositeType,\n  isEnumType,\n  isInputObjectType,\n  isNonNullType,\n  isObjectType,\n  isScalarType,\n  isSpecifiedScalarType,\n  isUnionType,\n  Kind,\n  NameNode,\n  TypeInfo,\n  visit,\n  visitWithTypeInfo,\n} from \"graphql\";\nimport {\n  CompositeTypeTuple,\n  DirectiveDefinitionTuple,\n  DirectiveKeys,\n  SchemaFragmentDefinitions,\n  EnumTypeDefinitionTuple,\n  FieldDefinition,\n  FieldKeys,\n  InputObjectKeys,\n  InputObjectTypeDefinitionTuple,\n  InputValueDefinition,\n  InputValueDefinitionRecord,\n  InputValueKeys,\n  InterfaceKeys,\n  InterfaceTypeDefinitionTuple,\n  ObjectKeys,\n  ObjectTypeDefinitionTuple,\n  ScalarTypeDefinitionTuple,\n  TypeDefinitionsRecord,\n  TypeKind,\n  TypeReference,\n} from \"../schema/definition\";\nimport {\n  inspectTypeReference,\n  typeNameFromReference,\n  typeReferenceFromName,\n} from \"../schema/reference\";\nimport { invariant } from \"../jsutils/invariant\";\nimport { Maybe } from \"../jsutils/Maybe\";\nimport {\n  isSpecifiedDirective,\n  SUPERMASSIVE_SCHEMA_DIRECTIVE_FRAGMENT_ARGUMENT_NAME,\n  SUPERMASSIVE_SCHEMA_DIRECTIVE_NAME,\n} from \"../schema/directives\";\nimport { makeReadableErrorPath } from \"./makeReadableErrorPath\";\n\nexport type AddMinimalViableSchemaToRequestDocumentOptions = {\n  ignoredDirectives?: string[];\n  includeImplementations?: boolean; // TODO\n};\n\nexport function addMinimalViableSchemaToRequestDocument(\n  schema: GraphQLSchema,\n  document: DocumentNode,\n  options?: AddMinimalViableSchemaToRequestDocumentOptions,\n): DocumentNode {\n  return {\n    ...document,\n    definitions: document.definitions.map((node) =>\n      node.kind === Kind.OPERATION_DEFINITION ||\n      node.kind === Kind.FRAGMENT_DEFINITION\n        ? addMinimalViableSchemaToExecutableDefinitionNode(\n            schema,\n            node,\n            options,\n          )\n        : node,\n    ),\n  };\n}\n\n/**\n * Adds directive with minimal viable schema to every individual executable node (operation, fragment)\n */\nfunction addMinimalViableSchemaToExecutableDefinitionNode<\n  T extends ExecutableDefinitionNode,\n>(\n  schema: GraphQLSchema,\n  node: T,\n  options?: AddMinimalViableSchemaToRequestDocumentOptions,\n): T {\n  if (node.directives?.some((directive) => directive.name.value === \"schema\")) {\n    return node;\n  }\n  const schemaFragment = extractMinimalViableSchemaForRequestDocument(\n    schema,\n    { kind: Kind.DOCUMENT, definitions: [node] },\n    options,\n  );\n  const directive: DirectiveNode = {\n    kind: Kind.DIRECTIVE,\n    name: nameNode(SUPERMASSIVE_SCHEMA_DIRECTIVE_NAME),\n    arguments: [\n      argNode(\n        SUPERMASSIVE_SCHEMA_DIRECTIVE_FRAGMENT_ARGUMENT_NAME,\n        schemaFragment,\n      ),\n    ],\n  };\n  return {\n    ...node,\n    directives: [...(node.directives ?? []), directive],\n  };\n}\n\nfunction nameNode(name: string): NameNode {\n  return { kind: Kind.NAME, value: name };\n}\n\nfunction argNode(name: string, value: unknown): ArgumentNode {\n  return {\n    kind: Kind.ARGUMENT,\n    name: nameNode(name),\n    value: { kind: Kind.STRING, value: JSON.stringify(value) },\n  };\n}\n\nexport function extractMinimalViableSchemaForRequestDocument(\n  schema: GraphQLSchema,\n  document: DocumentNode,\n  options?: AddMinimalViableSchemaToRequestDocumentOptions,\n): SchemaFragmentDefinitions {\n  const types: TypeDefinitionsRecord = Object.create(null);\n  const directives: DirectiveDefinitionTuple[] = [];\n\n  const typeInfo = new TypeInfo(schema);\n  visit(\n    document,\n    visitWithTypeInfo(typeInfo, {\n      Field(node, _key, _parent, _path, ancestors): void {\n        const parentType = typeInfo.getParentType();\n        assertCompositeType(parentType, node, ancestors);\n\n        const typeDef = addCompositeType(types, parentType);\n        if (typeDef[0] === TypeKind.UNION || node.name.value === \"__typename\") {\n          return;\n        }\n        const field = typeInfo.getFieldDef();\n        assertExistingField(field, node, ancestors);\n        assertAllArgumentsAreDefined(field, node, ancestors);\n\n        const fieldDef = addField(typeDef, field, node);\n        if (Array.isArray(fieldDef)) {\n          addReferencedOutputType(schema, types, fieldDef[FieldKeys.type]);\n          addReferencedInputTypes(schema, types, fieldDef[FieldKeys.arguments]);\n        } else {\n          addReferencedOutputType(schema, types, fieldDef);\n        }\n      },\n      Directive(node, _key, _parent, _path, ancestors) {\n        if (\n          isSpecifiedDirective(node.name.value) ||\n          options?.ignoredDirectives?.includes(node.name.value)\n        ) {\n          return;\n        }\n        const directive = typeInfo.getDirective();\n        if (!directive) {\n          const errorPath = makeReadableErrorPath(ancestors);\n\n          // This happens whenever a directive is requested that hasn't been defined in schema\n          throw new GraphQLError(\n            `Cannot find definition for directive: ${errorPath.join(\".\")} @${\n              node.name.value\n            }`,\n            { nodes: node },\n          );\n        }\n        addDirective(directives, directive, node);\n      },\n      FragmentDefinition(node, _key, _parent, _path, ancestors): void {\n        const type = typeInfo.getType();\n        assertCompositeType(type, node, ancestors);\n        addCompositeType(types, type);\n      },\n      InlineFragment(node, _key, _parent, _path, ancestors): void {\n        if (node?.typeCondition) {\n          const type = typeInfo.getType();\n          assertCompositeType(type, node, ancestors);\n          addCompositeType(types, type);\n        }\n      },\n      Argument() {\n        // Perf: no need to visit arguments - they were handled by Field/Directive visitors\n        return false;\n      },\n    }),\n  );\n  return directives.length ? { types, directives } : { types };\n}\n\nfunction addReferencedOutputType(\n  schema: GraphQLSchema,\n  types: TypeDefinitionsRecord,\n  typeRef: TypeReference,\n) {\n  const name = typeNameFromReference(typeRef);\n  const schemaType = schema.getType(name);\n\n  if (!schemaType) {\n    throw new Error(`Type ${name} not found in schema`);\n  }\n  if (types[name] || isSpecifiedScalarType(schemaType)) {\n    // Assuming already added\n    return;\n  }\n  if (isCompositeType(schemaType)) {\n    addCompositeType(types, schemaType);\n  } else if (isEnumType(schemaType)) {\n    types[name] = encodeEnumType(schemaType);\n  } else if (isScalarType(schemaType)) {\n    types[name] = encodeScalarType(schemaType);\n  } else {\n    invariant(false, \"Got non-output type: \" + inspectTypeReference(typeRef));\n  }\n}\n\nfunction addReferencedInputTypes(\n  schema: GraphQLSchema,\n  types: TypeDefinitionsRecord,\n  inputValues: InputValueDefinitionRecord,\n): void {\n  for (const inputValueDef of Object.values(inputValues)) {\n    const typeRef = Array.isArray(inputValueDef)\n      ? inputValueDef[InputValueKeys.type]\n      : inputValueDef;\n\n    const name = typeNameFromReference(typeRef);\n    const schemaType = schema.getType(name);\n\n    if (!schemaType) {\n      throw new Error(`Type ${name} not found in schema`);\n    }\n    if (types[name] || isSpecifiedScalarType(schemaType)) {\n      // Assuming already fully added\n      continue;\n    }\n    if (isInputObjectType(schemaType)) {\n      const inputObjectDef = encodeInputObjectType(schemaType);\n      types[name] = inputObjectDef;\n      addReferencedInputTypes(\n        schema,\n        types,\n        inputObjectDef[InputObjectKeys.fields],\n      );\n    } else if (isEnumType(schemaType)) {\n      types[name] = encodeEnumType(schemaType);\n    } else if (isScalarType(schemaType)) {\n      types[name] = encodeScalarType(schemaType);\n    } else {\n      invariant(false, \"Got non-input type: \" + inspectTypeReference(typeRef));\n    }\n  }\n}\n\nfunction addCompositeType(\n  types: TypeDefinitionsRecord,\n  type: GraphQLCompositeType,\n): CompositeTypeTuple {\n  if (types[type.name]) {\n    // TODO: double check that the kind match?\n    return types[type.name] as CompositeTypeTuple;\n  }\n  return (types[type.name] = encodeCompositeType(type));\n}\n\nfunction addField(\n  type: ObjectTypeDefinitionTuple | InterfaceTypeDefinitionTuple,\n  field: GraphQLField<unknown, unknown>,\n  fieldNode: FieldNode,\n): FieldDefinition {\n  const fields =\n    type[0] === TypeKind.OBJECT\n      ? type[ObjectKeys.fields]\n      : type[InterfaceKeys.fields];\n\n  const existingFieldDef: FieldDefinition = fields[field.name];\n  const previouslyAddedArgs = Array.isArray(existingFieldDef)\n    ? existingFieldDef[FieldKeys.arguments]\n    : Object.create(null);\n\n  const nodeArgs = new Set(fieldNode.arguments?.map((arg) => arg.name.value));\n\n  const argsFilter = (argDef: GraphQLArgument) =>\n    Boolean(\n      previouslyAddedArgs[argDef.name] ||\n        isNonNullType(argDef.type) ||\n        argDef.defaultValue !== undefined ||\n        nodeArgs.has(argDef.name),\n    );\n\n  return (fields[field.name] = encodeFieldDef(field, argsFilter));\n}\n\nfunction addDirective(\n  directives: DirectiveDefinitionTuple[],\n  directive: GraphQLDirective,\n  node: DirectiveNode,\n) {\n  const name = directive.name;\n  let tuple = directives.find((d) => d[DirectiveKeys.name] === name);\n  if (!tuple) {\n    tuple = [directive.name];\n    directives.push(tuple);\n  }\n\n  const previouslyAddedArgs = tuple[DirectiveKeys.arguments];\n  const nodeArgs = new Set(node.arguments?.map((arg) => arg.name.value));\n\n  const argsFilter = (argDef: GraphQLArgument) =>\n    Boolean(\n      previouslyAddedArgs?.[argDef.name] ||\n        isNonNullType(argDef.type) ||\n        argDef.defaultValue !== undefined ||\n        nodeArgs.has(argDef.name),\n    );\n  const [hasArgs, argsRecord] = encodeArguments(directive.args, argsFilter);\n  if (hasArgs) {\n    tuple[DirectiveKeys.arguments] = argsRecord;\n  }\n  return tuple;\n}\n\nfunction encodeCompositeType(type: GraphQLCompositeType): CompositeTypeTuple {\n  if (isUnionType(type)) {\n    return [TypeKind.UNION, type.getTypes().map((type) => type.name)];\n  }\n  const ifaces = type.getInterfaces().map((iface) => iface.name);\n  const typeKind = isObjectType(type) ? TypeKind.OBJECT : TypeKind.INTERFACE;\n  return ifaces.length ? [typeKind, {}, ifaces] : [typeKind, {}];\n}\n\nfunction encodeInputObjectType(\n  type: GraphQLInputObjectType,\n): InputObjectTypeDefinitionTuple {\n  const result = Object.create(null);\n  for (const [fieldName, field] of Object.entries(type.getFields())) {\n    result[fieldName] = encodeInputField(field);\n  }\n  return [TypeKind.INPUT, result];\n}\n\nfunction encodeInputField(field: GraphQLInputField): InputValueDefinition {\n  const typeReference = typeReferenceFromName(field.type.toString());\n  return field.defaultValue === undefined\n    ? typeReference\n    : [typeReference, field.defaultValue];\n}\n\nfunction encodeFieldDef(\n  field: GraphQLField<unknown, unknown>,\n  argumentsFilter?: (arg: GraphQLArgument) => boolean,\n): FieldDefinition {\n  const typeReference = typeReferenceFromName(field.type.toString());\n  const [hasArgs, argsRecord] = encodeArguments(field.args, argumentsFilter);\n  return !hasArgs ? typeReference : [typeReference, argsRecord];\n}\n\nfunction encodeArguments(\n  args: ReadonlyArray<GraphQLArgument>,\n  argumentsFilter?: (arg: GraphQLArgument) => boolean,\n): [boolean, InputValueDefinitionRecord] {\n  let hasArgs = false;\n  const argsRecord: InputValueDefinitionRecord = {};\n  for (const argDef of args) {\n    if (argumentsFilter && !argumentsFilter(argDef)) {\n      continue;\n    }\n    const typeReference = typeReferenceFromName(argDef.type.toString());\n    argsRecord[argDef.name] =\n      argDef.defaultValue === undefined\n        ? typeReference\n        : [typeReference, argDef.defaultValue];\n    hasArgs = true;\n  }\n  return [hasArgs, argsRecord];\n}\n\nfunction encodeEnumType(type: GraphQLEnumType): EnumTypeDefinitionTuple {\n  return [TypeKind.ENUM, type.getValues().map((v) => v.name)];\n}\n\nfunction encodeScalarType(_type: GraphQLScalarType): ScalarTypeDefinitionTuple {\n  return [TypeKind.SCALAR];\n}\n\nfunction assertCompositeType(\n  type: Maybe<GraphQLOutputType>,\n  node: ASTNode,\n  ancestors: ReadonlyArray<readonly ASTNode[] | ASTNode>,\n): asserts type is GraphQLCompositeType {\n  if (!type || !isCompositeType(type)) {\n    const path =\n      node.kind === Kind.FIELD\n        ? makeReadableErrorPath(ancestors).join(\".\") + \".\" + node.name.value\n        : makeReadableErrorPath(ancestors).join(\".\");\n    throw new GraphQLError(`Cannot find type for: ${path}`, {\n      nodes: node,\n    });\n  }\n}\n\nfunction assertExistingField(\n  field: Maybe<GraphQLField<unknown, unknown>>,\n  node: FieldNode,\n  ancestors: ReadonlyArray<readonly ASTNode[] | ASTNode>,\n): asserts field is GraphQLField<unknown, unknown> {\n  if (!field) {\n    const path =\n      makeReadableErrorPath(ancestors).join(\".\") + \".\" + node.name.value;\n    throw new GraphQLError(`Cannot find field: ${path}`, { nodes: node });\n  }\n}\n\nfunction assertAllArgumentsAreDefined(\n  field: GraphQLField<unknown, unknown> | GraphQLDirective,\n  node: FieldNode | DirectiveNode,\n  ancestors: ReadonlyArray<readonly ASTNode[] | ASTNode>,\n) {\n  const defArgs = new Set(field.args.map((arg) => arg.name));\n  for (const arg of node.arguments ?? []) {\n    if (!defArgs.has(arg.name.value)) {\n      const path =\n        makeReadableErrorPath(ancestors).join(\".\") +\n        \".\" +\n        node.name.value +\n        `(${arg.name.value}: ...)`;\n      throw new GraphQLError(`Cannot find type for argument: ${path}`, {\n        nodes: arg,\n      });\n    }\n  }\n}\n"],
+  "mappings": "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",
+  "names": ["directive", "type"]
+}

package/lib/utilities/annotateDocumentGraphQLTransform.d.ts

@@ -0,0 +1,3 @@
+import { FragmentDefinitionNode, GraphQLSchema, OperationDefinitionNode } from "graphql";
+export declare const annotateDocumentGraphQLTransform: (schema: GraphQLSchema) => (node: FragmentDefinitionNode | OperationDefinitionNode) => import("graphql").DefinitionNode;
+//# sourceMappingURL=annotateDocumentGraphQLTransform.d.ts.map

package/lib/utilities/annotateDocumentGraphQLTransform.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"annotateDocumentGraphQLTransform.d.ts","sourceRoot":"","sources":["../../src/utilities/annotateDocumentGraphQLTransform.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,sBAAsB,EACtB,aAAa,EAEb,uBAAuB,EACxB,MAAM,SAAS,CAAC;AAGjB,eAAO,MAAM,gCAAgC,WAAY,aAAa,YACtD,sBAAsB,GAAG,uBAAuB,qCAO/D,CAAC"}

package/lib/utilities/annotateDocumentGraphQLTransform.js

@@ -0,0 +1,34 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 annotateDocumentGraphQLTransform_exports = {};
+__export(annotateDocumentGraphQLTransform_exports, {
+  annotateDocumentGraphQLTransform: () => annotateDocumentGraphQLTransform
+});
+module.exports = __toCommonJS(annotateDocumentGraphQLTransform_exports);
+var import_graphql = require("graphql");
+var import_addMinimalViableSchemaToRequestDocument = require("./addMinimalViableSchemaToRequestDocument");
+const annotateDocumentGraphQLTransform = (schema) => {
+  return (node) => {
+    const document = (0, import_addMinimalViableSchemaToRequestDocument.addMinimalViableSchemaToRequestDocument)(schema, {
+      kind: import_graphql.Kind.DOCUMENT,
+      definitions: [node]
+    });
+    return document == null ? void 0 : document.definitions[0];
+  };
+};

package/lib/utilities/annotateDocumentGraphQLTransform.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/annotateDocumentGraphQLTransform.ts"],
+  "sourcesContent": ["import {\n  FragmentDefinitionNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n} from \"graphql\";\nimport { addMinimalViableSchemaToRequestDocument } from \"./addMinimalViableSchemaToRequestDocument\";\n\nexport const annotateDocumentGraphQLTransform = (schema: GraphQLSchema) => {\n  return (node: FragmentDefinitionNode | OperationDefinitionNode) => {\n    const document = addMinimalViableSchemaToRequestDocument(schema, {\n      kind: Kind.DOCUMENT,\n      definitions: [node],\n    });\n    return document?.definitions[0]; // FIXME\n  };\n};\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAKO;AACP,qDAAwD;AAEjD,MAAM,mCAAmC,CAAC,WAA0B;AACzE,SAAO,CAAC,SAA2D;AACjE,UAAM,eAAW,wFAAwC,QAAQ;AAAA,MAC/D,MAAM,oBAAK;AAAA,MACX,aAAa,CAAC,IAAI;AAAA,IACpB,CAAC;AACD,WAAO,qCAAU,YAAY;AAAA,EAC/B;AACF;",
+  "names": []
+}

package/lib/utilities/annotateDocumentGraphQLTransform.mjs

@@ -0,0 +1,17 @@
+// src/utilities/annotateDocumentGraphQLTransform.ts
+import {
+  Kind
+} from "graphql";
+import { addMinimalViableSchemaToRequestDocument } from "./addMinimalViableSchemaToRequestDocument.mjs";
+var annotateDocumentGraphQLTransform = (schema) => {
+  return (node) => {
+    const document = addMinimalViableSchemaToRequestDocument(schema, {
+      kind: Kind.DOCUMENT,
+      definitions: [node]
+    });
+    return document == null ? void 0 : document.definitions[0];
+  };
+};
+export {
+  annotateDocumentGraphQLTransform
+};

package/lib/utilities/annotateDocumentGraphQLTransform.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/annotateDocumentGraphQLTransform.ts"],
+  "sourcesContent": ["import {\n  FragmentDefinitionNode,\n  GraphQLSchema,\n  Kind,\n  OperationDefinitionNode,\n} from \"graphql\";\nimport { addMinimalViableSchemaToRequestDocument } from \"./addMinimalViableSchemaToRequestDocument\";\n\nexport const annotateDocumentGraphQLTransform = (schema: GraphQLSchema) => {\n  return (node: FragmentDefinitionNode | OperationDefinitionNode) => {\n    const document = addMinimalViableSchemaToRequestDocument(schema, {\n      kind: Kind.DOCUMENT,\n      definitions: [node],\n    });\n    return document?.definitions[0]; // FIXME\n  };\n};\n"],
+  "mappings": ";AAAA;AAAA,EAGE;AAAA,OAEK;AACP,SAAS,+CAA+C;AAEjD,IAAM,mCAAmC,CAAC,WAA0B;AACzE,SAAO,CAAC,SAA2D;AACjE,UAAM,WAAW,wCAAwC,QAAQ;AAAA,MAC/D,MAAM,KAAK;AAAA,MACX,aAAa,CAAC,IAAI;AAAA,IACpB,CAAC;AACD,WAAO,qCAAU,YAAY;AAAA,EAC/B;AACF;",
+  "names": []
+}

package/lib/utilities/coerceInputValue.d.ts

@@ -0,0 +1,10 @@
+import { GraphQLError } from "graphql";
+import { TypeReference } from "../schema/definition";
+import { SchemaFragment } from "../schema/fragment";
+type OnErrorCB = (path: ReadonlyArray<string | number>, invalidValue: unknown, error: GraphQLError) => void;
+/**
+ * Coerces a JavaScript value given a GraphQL Input Type.
+ */
+export declare function coerceInputValue(inputValue: unknown, typeRef: TypeReference, schemaTypes: SchemaFragment, onError?: OnErrorCB): unknown;
+export {};
+//# sourceMappingURL=coerceInputValue.d.ts.map

package/lib/utilities/coerceInputValue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"coerceInputValue.d.ts","sourceRoot":"","sources":["../../src/utilities/coerceInputValue.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,YAAY,EAAE,MAAM,SAAS,CAAC;AAUvC,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AAQpD,KAAK,SAAS,GAAG,CACf,IAAI,EAAE,aAAa,CAAC,MAAM,GAAG,MAAM,CAAC,EACpC,YAAY,EAAE,OAAO,EACrB,KAAK,EAAE,YAAY,KAChB,IAAI,CAAC;AAEV;;GAEG;AACH,wBAAgB,gBAAgB,CAC9B,UAAU,EAAE,OAAO,EACnB,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,cAAc,EAC3B,OAAO,GAAE,SAA0B,GAClC,OAAO,CAQT"}

package/lib/utilities/coerceInputValue.js

@@ -0,0 +1,181 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+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 coerceInputValue_exports = {};
+__export(coerceInputValue_exports, {
+  coerceInputValue: () => coerceInputValue
+});
+module.exports = __toCommonJS(coerceInputValue_exports);
+var import_graphql = require("graphql");
+var import_didYouMean = require("../jsutils/didYouMean");
+var import_inspect = require("../jsutils/inspect");
+var import_invariant = require("../jsutils/invariant");
+var import_isIterableObject = require("../jsutils/isIterableObject");
+var import_isObjectLike = require("../jsutils/isObjectLike");
+var import_Path = require("../jsutils/Path");
+var import_printPathArray = require("../jsutils/printPathArray");
+var import_suggestionList = require("../jsutils/suggestionList");
+var import_reference = require("../schema/reference");
+function coerceInputValue(inputValue, typeRef, schemaTypes, onError = defaultOnError) {
+  return coerceInputValueImpl(
+    inputValue,
+    typeRef,
+    schemaTypes,
+    onError,
+    void 0
+  );
+}
+function defaultOnError(path, invalidValue, error) {
+  let errorPrefix = "Invalid value " + (0, import_inspect.inspect)(invalidValue);
+  if (path.length > 0) {
+    errorPrefix += ` at "value${(0, import_printPathArray.printPathArray)(path)}"`;
+  }
+  error.message = errorPrefix + ": " + error.message;
+  throw error;
+}
+function coerceInputValueImpl(inputValue, typeRef, schemaTypes, onError, path) {
+  if ((0, import_reference.isNonNullType)(typeRef)) {
+    if (inputValue != null) {
+      return coerceInputValueImpl(
+        inputValue,
+        (0, import_reference.unwrap)(typeRef),
+        schemaTypes,
+        onError,
+        path
+      );
+    }
+    onError(
+      (0, import_Path.pathToArray)(path),
+      inputValue,
+      new import_graphql.GraphQLError(
+        `Expected non-nullable type "${(0, import_reference.inspectTypeReference)(
+          typeRef
+        )}" not to be null.`
+      )
+    );
+    return;
+  }
+  if (inputValue == null) {
+    return null;
+  }
+  if ((0, import_reference.isListType)(typeRef)) {
+    const itemType = (0, import_reference.unwrap)(typeRef);
+    if ((0, import_isIterableObject.isIterableObject)(inputValue)) {
+      return Array.from(inputValue, (itemValue, index) => {
+        const itemPath = (0, import_Path.addPath)(path, index, void 0);
+        return coerceInputValueImpl(
+          itemValue,
+          itemType,
+          schemaTypes,
+          onError,
+          itemPath
+        );
+      });
+    }
+    return [
+      coerceInputValueImpl(inputValue, itemType, schemaTypes, onError, path)
+    ];
+  }
+  const inputObjectType = schemaTypes.getInputObjectType(typeRef);
+  if (inputObjectType) {
+    const typeName = (0, import_reference.inspectTypeReference)(typeRef);
+    if (!(0, import_isObjectLike.isObjectLike)(inputValue)) {
+      onError(
+        (0, import_Path.pathToArray)(path),
+        inputValue,
+        new import_graphql.GraphQLError(`Expected type "${typeRef}" to be an object.`)
+      );
+      return;
+    }
+    const coercedValue = {};
+    const fieldDefs = schemaTypes.getInputObjectFields(inputObjectType);
+    for (const [fieldName, field] of Object.entries(fieldDefs)) {
+      const fieldValue = inputValue[fieldName];
+      const defaultValue = schemaTypes.getInputDefaultValue(field);
+      const fieldTypeRef = schemaTypes.getTypeReference(field);
+      if (fieldValue === void 0) {
+        if (defaultValue !== void 0) {
+          coercedValue[fieldName] = defaultValue;
+        } else if ((0, import_reference.isNonNullType)(fieldTypeRef)) {
+          const typeStr = (0, import_reference.inspectTypeReference)(fieldTypeRef);
+          onError(
+            (0, import_Path.pathToArray)(path),
+            inputValue,
+            new import_graphql.GraphQLError(
+              `Field "${fieldName}" of required type "${typeStr}" was not provided.`
+            )
+          );
+        }
+        continue;
+      }
+      coercedValue[fieldName] = coerceInputValueImpl(
+        fieldValue,
+        fieldTypeRef,
+        schemaTypes,
+        onError,
+        (0, import_Path.addPath)(path, fieldName, typeName)
+      );
+    }
+    for (const fieldName of Object.keys(inputValue)) {
+      if (fieldDefs[fieldName] == null) {
+        const suggestions = (0, import_suggestionList.suggestionList)(fieldName, Object.keys(fieldDefs));
+        onError(
+          (0, import_Path.pathToArray)(path),
+          inputValue,
+          new import_graphql.GraphQLError(
+            `Field "${fieldName}" is not defined by type "${typeName}".` + (0, import_didYouMean.didYouMean)(suggestions)
+          )
+        );
+      }
+    }
+    return coercedValue;
+  }
+  const leafType = schemaTypes.getLeafTypeResolver(typeRef);
+  if (leafType) {
+    let parseResult;
+    try {
+      parseResult = leafType.parseValue(inputValue);
+    } catch (error) {
+      if (error instanceof import_graphql.GraphQLError) {
+        onError((0, import_Path.pathToArray)(path), inputValue, error);
+      } else {
+        const typeName = (0, import_reference.inspectTypeReference)(typeRef);
+        onError(
+          (0, import_Path.pathToArray)(path),
+          inputValue,
+          new import_graphql.GraphQLError(
+            `Expected type "${typeName}". ` + error.message,
+            {
+              originalError: error
+            }
+          )
+        );
+      }
+      return;
+    }
+    if (parseResult === void 0) {
+      onError(
+        (0, import_Path.pathToArray)(path),
+        inputValue,
+        new import_graphql.GraphQLError(`Expected type "${(0, import_reference.inspectTypeReference)(typeRef)}".`)
+      );
+    }
+    return parseResult;
+  }
+  (0, import_invariant.invariant)(false, "Unexpected input type: " + (0, import_reference.inspectTypeReference)(typeRef));
+}