@graphitation/supermassive 2.6.1 → 3.0.0-alpha.3

package/lib/utilities/makeReadableErrorPath.js

@@ -0,0 +1,47 @@
+"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 makeReadableErrorPath_exports = {};
+__export(makeReadableErrorPath_exports, {
+  makeReadableErrorPath: () => makeReadableErrorPath
+});
+module.exports = __toCommonJS(makeReadableErrorPath_exports);
+var import_graphql = require("graphql");
+function makeReadableErrorPath(ancestors) {
+  const path = [];
+  ancestors.forEach((ancestorOrArray) => {
+    let ancestor;
+    if (!Array.isArray(ancestorOrArray)) {
+      ancestor = ancestorOrArray;
+      if (ancestor && ancestor.kind === import_graphql.Kind.FIELD) {
+        path.push(ancestor.name.value);
+      } else if (ancestor && ancestor.kind === import_graphql.Kind.DIRECTIVE) {
+        path.push(`@${ancestor.name.value}`);
+      } else if (ancestor && ancestor.kind === import_graphql.Kind.OPERATION_DEFINITION) {
+        let name;
+        if (ancestor.name) {
+          name = `${ancestor.operation} ${ancestor.name.value}`;
+        } else {
+          name = ancestor.operation;
+        }
+        path.push(name);
+      }
+    }
+  });
+  return path;
+}

package/lib/utilities/makeReadableErrorPath.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/makeReadableErrorPath.ts"],
+  "sourcesContent": ["import { Kind, ASTNode } from \"graphql\";\n\nexport function makeReadableErrorPath(\n  ancestors: ReadonlyArray<readonly ASTNode[] | ASTNode>,\n): string[] {\n  const path: string[] = [];\n  ancestors.forEach((ancestorOrArray) => {\n    let ancestor: ASTNode;\n    if (!Array.isArray(ancestorOrArray)) {\n      ancestor = ancestorOrArray as ASTNode;\n      if (ancestor && ancestor.kind === Kind.FIELD) {\n        path.push(ancestor.name.value);\n      } else if (ancestor && ancestor.kind === Kind.DIRECTIVE) {\n        path.push(`@${ancestor.name.value}`);\n      } else if (ancestor && ancestor.kind === Kind.OPERATION_DEFINITION) {\n        let name;\n        if (ancestor.name) {\n          name = `${ancestor.operation} ${ancestor.name.value}`;\n        } else {\n          name = ancestor.operation;\n        }\n        path.push(name);\n      }\n    }\n  });\n  return path;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA8B;AAEvB,SAAS,sBACd,WACU;AACV,QAAM,OAAiB,CAAC;AACxB,YAAU,QAAQ,CAAC,oBAAoB;AACrC,QAAI;AACJ,QAAI,CAAC,MAAM,QAAQ,eAAe,GAAG;AACnC,iBAAW;AACX,UAAI,YAAY,SAAS,SAAS,oBAAK,OAAO;AAC5C,aAAK,KAAK,SAAS,KAAK,KAAK;AAAA,MAC/B,WAAW,YAAY,SAAS,SAAS,oBAAK,WAAW;AACvD,aAAK,KAAK,IAAI,SAAS,KAAK,OAAO;AAAA,MACrC,WAAW,YAAY,SAAS,SAAS,oBAAK,sBAAsB;AAClE,YAAI;AACJ,YAAI,SAAS,MAAM;AACjB,iBAAO,GAAG,SAAS,aAAa,SAAS,KAAK;AAAA,QAChD,OAAO;AACL,iBAAO,SAAS;AAAA,QAClB;AACA,aAAK,KAAK,IAAI;AAAA,MAChB;AAAA,IACF;AAAA,EACF,CAAC;AACD,SAAO;AACT;",
+  "names": []
+}

package/lib/utilities/makeReadableErrorPath.mjs

@@ -0,0 +1,28 @@
+// src/utilities/makeReadableErrorPath.ts
+import { Kind } from "graphql";
+function makeReadableErrorPath(ancestors) {
+  const path = [];
+  ancestors.forEach((ancestorOrArray) => {
+    let ancestor;
+    if (!Array.isArray(ancestorOrArray)) {
+      ancestor = ancestorOrArray;
+      if (ancestor && ancestor.kind === Kind.FIELD) {
+        path.push(ancestor.name.value);
+      } else if (ancestor && ancestor.kind === Kind.DIRECTIVE) {
+        path.push(`@${ancestor.name.value}`);
+      } else if (ancestor && ancestor.kind === Kind.OPERATION_DEFINITION) {
+        let name;
+        if (ancestor.name) {
+          name = `${ancestor.operation} ${ancestor.name.value}`;
+        } else {
+          name = ancestor.operation;
+        }
+        path.push(name);
+      }
+    }
+  });
+  return path;
+}
+export {
+  makeReadableErrorPath
+};

package/lib/utilities/makeReadableErrorPath.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/makeReadableErrorPath.ts"],
+  "sourcesContent": ["import { Kind, ASTNode } from \"graphql\";\n\nexport function makeReadableErrorPath(\n  ancestors: ReadonlyArray<readonly ASTNode[] | ASTNode>,\n): string[] {\n  const path: string[] = [];\n  ancestors.forEach((ancestorOrArray) => {\n    let ancestor: ASTNode;\n    if (!Array.isArray(ancestorOrArray)) {\n      ancestor = ancestorOrArray as ASTNode;\n      if (ancestor && ancestor.kind === Kind.FIELD) {\n        path.push(ancestor.name.value);\n      } else if (ancestor && ancestor.kind === Kind.DIRECTIVE) {\n        path.push(`@${ancestor.name.value}`);\n      } else if (ancestor && ancestor.kind === Kind.OPERATION_DEFINITION) {\n        let name;\n        if (ancestor.name) {\n          name = `${ancestor.operation} ${ancestor.name.value}`;\n        } else {\n          name = ancestor.operation;\n        }\n        path.push(name);\n      }\n    }\n  });\n  return path;\n}\n"],
+  "mappings": ";AAAA,SAAS,YAAqB;AAEvB,SAAS,sBACd,WACU;AACV,QAAM,OAAiB,CAAC;AACxB,YAAU,QAAQ,CAAC,oBAAoB;AACrC,QAAI;AACJ,QAAI,CAAC,MAAM,QAAQ,eAAe,GAAG;AACnC,iBAAW;AACX,UAAI,YAAY,SAAS,SAAS,KAAK,OAAO;AAC5C,aAAK,KAAK,SAAS,KAAK,KAAK;AAAA,MAC/B,WAAW,YAAY,SAAS,SAAS,KAAK,WAAW;AACvD,aAAK,KAAK,IAAI,SAAS,KAAK,OAAO;AAAA,MACrC,WAAW,YAAY,SAAS,SAAS,KAAK,sBAAsB;AAClE,YAAI;AACJ,YAAI,SAAS,MAAM;AACjB,iBAAO,GAAG,SAAS,aAAa,SAAS,KAAK;AAAA,QAChD,OAAO;AACL,iBAAO,SAAS;AAAA,QAClB;AACA,aAAK,KAAK,IAAI;AAAA,MAChB;AAAA,IACF;AAAA,EACF,CAAC;AACD,SAAO;AACT;",
+  "names": []
+}

package/lib/utilities/mergeDefinitions.d.ts

@@ -0,0 +1,8 @@
+import { DirectiveDefinitionTuple, SchemaFragmentDefinitions, TypeDefinitionsRecord } from "../schema/definition";
+export declare function mergeSchemaDefinitions(target: SchemaFragmentDefinitions, sources: SchemaFragmentDefinitions[]): SchemaFragmentDefinitions | undefined;
+export declare function mergeDirectives(target: DirectiveDefinitionTuple[], source: DirectiveDefinitionTuple[]): void;
+/**
+ * Adds missing definitions from source into target. Mutates target in place.
+ */
+export declare function mergeTypes(target: TypeDefinitionsRecord, source: TypeDefinitionsRecord): void;
+//# sourceMappingURL=mergeDefinitions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"mergeDefinitions.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeDefinitions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,wBAAwB,EAQxB,yBAAyB,EACzB,qBAAqB,EAEtB,MAAM,sBAAsB,CAAC;AAG9B,wBAAgB,sBAAsB,CACpC,MAAM,EAAE,yBAAyB,EACjC,OAAO,EAAE,yBAAyB,EAAE,yCAiBrC;AAED,wBAAgB,eAAe,CAC7B,MAAM,EAAE,wBAAwB,EAAE,EAClC,MAAM,EAAE,wBAAwB,EAAE,QAuBnC;AAED;;GAEG;AACH,wBAAgB,UAAU,CACxB,MAAM,EAAE,qBAAqB,EAC7B,MAAM,EAAE,qBAAqB,GAC5B,IAAI,CAwCN"}

package/lib/utilities/mergeDefinitions.js

@@ -0,0 +1,126 @@
+"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 mergeDefinitions_exports = {};
+__export(mergeDefinitions_exports, {
+  mergeDirectives: () => mergeDirectives,
+  mergeSchemaDefinitions: () => mergeSchemaDefinitions,
+  mergeTypes: () => mergeTypes
+});
+module.exports = __toCommonJS(mergeDefinitions_exports);
+var import_definition = require("../schema/definition");
+var import_inspect = require("../jsutils/inspect");
+function mergeSchemaDefinitions(target, sources) {
+  var _a;
+  if (!sources.length) {
+    return target;
+  }
+  for (const source of sources) {
+    if (!target.types) {
+      target.types = source.types;
+    } else if (source.types) {
+      mergeTypes(target.types, source.types);
+    }
+    if (!target.directives) {
+      target.directives = source.directives;
+    } else if ((_a = source.directives) == null ? void 0 : _a.length) {
+      mergeDirectives(target.directives, source.directives);
+    }
+  }
+}
+function mergeDirectives(target, source) {
+  for (const sourceDirective of source) {
+    const targetDirective = target.find(
+      (directive) => directive[import_definition.DirectiveKeys.name] === sourceDirective[import_definition.DirectiveKeys.name]
+    );
+    if (!targetDirective) {
+      target.push(sourceDirective);
+      continue;
+    }
+    if (!sourceDirective[import_definition.DirectiveKeys.arguments]) {
+      continue;
+    }
+    if (!targetDirective[import_definition.DirectiveKeys.arguments]) {
+      targetDirective[import_definition.DirectiveKeys.arguments] = sourceDirective[import_definition.DirectiveKeys.arguments];
+    }
+    mergeInputValues(
+      targetDirective[import_definition.DirectiveKeys.arguments],
+      sourceDirective[import_definition.DirectiveKeys.arguments]
+    );
+  }
+}
+function mergeTypes(target, source) {
+  for (const [typeName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[typeName];
+    if (!targetDef) {
+      target[typeName] = sourceDef;
+      continue;
+    }
+    if (targetDef[0] === import_definition.TypeKind.OBJECT && sourceDef[0] === import_definition.TypeKind.OBJECT) {
+      mergeFields(targetDef[import_definition.ObjectKeys.fields], sourceDef[import_definition.ObjectKeys.fields]);
+      continue;
+    }
+    if (targetDef[0] === import_definition.TypeKind.INTERFACE && sourceDef[0] === import_definition.TypeKind.INTERFACE) {
+      mergeFields(
+        targetDef[import_definition.InterfaceKeys.fields],
+        sourceDef[import_definition.InterfaceKeys.fields]
+      );
+      continue;
+    }
+    if (targetDef[0] === import_definition.TypeKind.INPUT && sourceDef[0] === import_definition.TypeKind.INPUT) {
+      mergeInputValues(
+        targetDef[import_definition.InputObjectKeys.fields],
+        sourceDef[import_definition.InputObjectKeys.fields]
+      );
+      continue;
+    }
+    if (targetDef[0] !== sourceDef[0]) {
+      throw new Error(
+        `Type ${typeName} is represented differently in different schema fragments:
+` + (0, import_inspect.inspect)(targetDef) + `
+` + (0, import_inspect.inspect)(sourceDef)
+      );
+    }
+  }
+}
+function mergeFields(target, source) {
+  for (const [fieldName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[fieldName];
+    if (!target[fieldName] || !Array.isArray(targetDef)) {
+      target[fieldName] = sourceDef;
+      continue;
+    }
+    if (Array.isArray(sourceDef) && sourceDef[import_definition.FieldKeys.arguments]) {
+      if (!targetDef[import_definition.FieldKeys.arguments]) {
+        targetDef[import_definition.FieldKeys.arguments] = {};
+      }
+      mergeInputValues(
+        targetDef[import_definition.FieldKeys.arguments],
+        sourceDef[import_definition.FieldKeys.arguments]
+      );
+    }
+  }
+}
+function mergeInputValues(target, source) {
+  for (const [fieldName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[fieldName];
+    if (!target[fieldName] || !Array.isArray(targetDef)) {
+      target[fieldName] = sourceDef;
+    }
+  }
+}

package/lib/utilities/mergeDefinitions.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/mergeDefinitions.ts"],
+  "sourcesContent": ["import {\n  DirectiveDefinitionTuple,\n  DirectiveKeys,\n  FieldDefinitionRecord,\n  FieldKeys,\n  InputObjectKeys,\n  InputValueDefinitionRecord,\n  InterfaceKeys,\n  ObjectKeys,\n  SchemaFragmentDefinitions,\n  TypeDefinitionsRecord,\n  TypeKind,\n} from \"../schema/definition\";\nimport { inspect } from \"../jsutils/inspect\";\n\nexport function mergeSchemaDefinitions(\n  target: SchemaFragmentDefinitions,\n  sources: SchemaFragmentDefinitions[],\n) {\n  if (!sources.length) {\n    return target;\n  }\n  for (const source of sources) {\n    if (!target.types) {\n      target.types = source.types;\n    } else if (source.types) {\n      mergeTypes(target.types, source.types);\n    }\n    if (!target.directives) {\n      target.directives = source.directives;\n    } else if (source.directives?.length) {\n      mergeDirectives(target.directives, source.directives);\n    }\n  }\n}\n\nexport function mergeDirectives(\n  target: DirectiveDefinitionTuple[],\n  source: DirectiveDefinitionTuple[],\n) {\n  for (const sourceDirective of source) {\n    const targetDirective = target.find(\n      (directive) =>\n        directive[DirectiveKeys.name] === sourceDirective[DirectiveKeys.name],\n    );\n    if (!targetDirective) {\n      target.push(sourceDirective);\n      continue;\n    }\n    if (!sourceDirective[DirectiveKeys.arguments]) {\n      continue;\n    }\n    if (!targetDirective[DirectiveKeys.arguments]) {\n      targetDirective[DirectiveKeys.arguments] =\n        sourceDirective[DirectiveKeys.arguments];\n    }\n    mergeInputValues(\n      targetDirective[DirectiveKeys.arguments],\n      sourceDirective[DirectiveKeys.arguments],\n    );\n  }\n}\n\n/**\n * Adds missing definitions from source into target. Mutates target in place.\n */\nexport function mergeTypes(\n  target: TypeDefinitionsRecord,\n  source: TypeDefinitionsRecord,\n): void {\n  for (const [typeName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[typeName];\n    if (!targetDef) {\n      target[typeName] = sourceDef;\n      continue;\n    }\n    if (targetDef[0] === TypeKind.OBJECT && sourceDef[0] === TypeKind.OBJECT) {\n      mergeFields(targetDef[ObjectKeys.fields], sourceDef[ObjectKeys.fields]);\n      // Note: not merging implemented interfaces - assuming they are fully defined by the first occurrence\n      continue;\n    }\n    if (\n      targetDef[0] === TypeKind.INTERFACE &&\n      sourceDef[0] === TypeKind.INTERFACE\n    ) {\n      mergeFields(\n        targetDef[InterfaceKeys.fields],\n        sourceDef[InterfaceKeys.fields],\n      );\n      // Note: not merging implemented interfaces - assuming they are fully defined by the first occurrence\n      continue;\n    }\n    if (targetDef[0] === TypeKind.INPUT && sourceDef[0] === TypeKind.INPUT) {\n      mergeInputValues(\n        targetDef[InputObjectKeys.fields],\n        sourceDef[InputObjectKeys.fields],\n      );\n      continue;\n    }\n    // Note: not merging scalars, unions and enums - assuming they are fully defined by the first occurrence\n    if (targetDef[0] !== sourceDef[0]) {\n      throw new Error(\n        `Type ${typeName} is represented differently in different schema fragments:\\n` +\n          inspect(targetDef) +\n          `\\n` +\n          inspect(sourceDef),\n      );\n    }\n  }\n}\n\nfunction mergeFields(\n  target: FieldDefinitionRecord,\n  source: FieldDefinitionRecord,\n) {\n  for (const [fieldName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[fieldName];\n    if (!target[fieldName] || !Array.isArray(targetDef)) {\n      target[fieldName] = sourceDef;\n      continue;\n    }\n    if (Array.isArray(sourceDef) && sourceDef[FieldKeys.arguments]) {\n      if (!targetDef[FieldKeys.arguments]) {\n        targetDef[FieldKeys.arguments] = {};\n      }\n      mergeInputValues(\n        targetDef[FieldKeys.arguments],\n        sourceDef[FieldKeys.arguments],\n      );\n    }\n  }\n}\n\nfunction mergeInputValues(\n  target: InputValueDefinitionRecord,\n  source: InputValueDefinitionRecord,\n) {\n  for (const [fieldName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[fieldName];\n    if (!target[fieldName] || !Array.isArray(targetDef)) {\n      target[fieldName] = sourceDef;\n    }\n    // Note: not merging defaultValue - assuming it is fully defined by the first occurrence\n  }\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/utilities/mergeDefinitions.mjs

@@ -0,0 +1,114 @@
+// src/utilities/mergeDefinitions.ts
+import {
+  DirectiveKeys,
+  FieldKeys,
+  InputObjectKeys,
+  InterfaceKeys,
+  ObjectKeys,
+  TypeKind
+} from "../schema/definition.mjs";
+import { inspect } from "../jsutils/inspect.mjs";
+function mergeSchemaDefinitions(target, sources) {
+  var _a;
+  if (!sources.length) {
+    return target;
+  }
+  for (const source of sources) {
+    if (!target.types) {
+      target.types = source.types;
+    } else if (source.types) {
+      mergeTypes(target.types, source.types);
+    }
+    if (!target.directives) {
+      target.directives = source.directives;
+    } else if ((_a = source.directives) == null ? void 0 : _a.length) {
+      mergeDirectives(target.directives, source.directives);
+    }
+  }
+}
+function mergeDirectives(target, source) {
+  for (const sourceDirective of source) {
+    const targetDirective = target.find(
+      (directive) => directive[DirectiveKeys.name] === sourceDirective[DirectiveKeys.name]
+    );
+    if (!targetDirective) {
+      target.push(sourceDirective);
+      continue;
+    }
+    if (!sourceDirective[DirectiveKeys.arguments]) {
+      continue;
+    }
+    if (!targetDirective[DirectiveKeys.arguments]) {
+      targetDirective[DirectiveKeys.arguments] = sourceDirective[DirectiveKeys.arguments];
+    }
+    mergeInputValues(
+      targetDirective[DirectiveKeys.arguments],
+      sourceDirective[DirectiveKeys.arguments]
+    );
+  }
+}
+function mergeTypes(target, source) {
+  for (const [typeName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[typeName];
+    if (!targetDef) {
+      target[typeName] = sourceDef;
+      continue;
+    }
+    if (targetDef[0] === TypeKind.OBJECT && sourceDef[0] === TypeKind.OBJECT) {
+      mergeFields(targetDef[ObjectKeys.fields], sourceDef[ObjectKeys.fields]);
+      continue;
+    }
+    if (targetDef[0] === TypeKind.INTERFACE && sourceDef[0] === TypeKind.INTERFACE) {
+      mergeFields(
+        targetDef[InterfaceKeys.fields],
+        sourceDef[InterfaceKeys.fields]
+      );
+      continue;
+    }
+    if (targetDef[0] === TypeKind.INPUT && sourceDef[0] === TypeKind.INPUT) {
+      mergeInputValues(
+        targetDef[InputObjectKeys.fields],
+        sourceDef[InputObjectKeys.fields]
+      );
+      continue;
+    }
+    if (targetDef[0] !== sourceDef[0]) {
+      throw new Error(
+        `Type ${typeName} is represented differently in different schema fragments:
+` + inspect(targetDef) + `
+` + inspect(sourceDef)
+      );
+    }
+  }
+}
+function mergeFields(target, source) {
+  for (const [fieldName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[fieldName];
+    if (!target[fieldName] || !Array.isArray(targetDef)) {
+      target[fieldName] = sourceDef;
+      continue;
+    }
+    if (Array.isArray(sourceDef) && sourceDef[FieldKeys.arguments]) {
+      if (!targetDef[FieldKeys.arguments]) {
+        targetDef[FieldKeys.arguments] = {};
+      }
+      mergeInputValues(
+        targetDef[FieldKeys.arguments],
+        sourceDef[FieldKeys.arguments]
+      );
+    }
+  }
+}
+function mergeInputValues(target, source) {
+  for (const [fieldName, sourceDef] of Object.entries(source)) {
+    const targetDef = target[fieldName];
+    if (!target[fieldName] || !Array.isArray(targetDef)) {
+      target[fieldName] = sourceDef;
+    }
+  }
+}
+export {
+  mergeDirectives,
+  mergeSchemaDefinitions,
+  mergeTypes
+};

package/lib/utilities/mergeDefinitions.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/mergeDefinitions.ts"],
+  "sourcesContent": ["import {\n  DirectiveDefinitionTuple,\n  DirectiveKeys,\n  FieldDefinitionRecord,\n  FieldKeys,\n  InputObjectKeys,\n  InputValueDefinitionRecord,\n  InterfaceKeys,\n  ObjectKeys,\n  SchemaFragmentDefinitions,\n  TypeDefinitionsRecord,\n  TypeKind,\n} from \"../schema/definition\";\nimport { inspect } from \"../jsutils/inspect\";\n\nexport function mergeSchemaDefinitions(\n  target: SchemaFragmentDefinitions,\n  sources: SchemaFragmentDefinitions[],\n) {\n  if (!sources.length) {\n    return target;\n  }\n  for (const source of sources) {\n    if (!target.types) {\n      target.types = source.types;\n    } else if (source.types) {\n      mergeTypes(target.types, source.types);\n    }\n    if (!target.directives) {\n      target.directives = source.directives;\n    } else if (source.directives?.length) {\n      mergeDirectives(target.directives, source.directives);\n    }\n  }\n}\n\nexport function mergeDirectives(\n  target: DirectiveDefinitionTuple[],\n  source: DirectiveDefinitionTuple[],\n) {\n  for (const sourceDirective of source) {\n    const targetDirective = target.find(\n      (directive) =>\n        directive[DirectiveKeys.name] === sourceDirective[DirectiveKeys.name],\n    );\n    if (!targetDirective) {\n      target.push(sourceDirective);\n      continue;\n    }\n    if (!sourceDirective[DirectiveKeys.arguments]) {\n      continue;\n    }\n    if (!targetDirective[DirectiveKeys.arguments]) {\n      targetDirective[DirectiveKeys.arguments] =\n        sourceDirective[DirectiveKeys.arguments];\n    }\n    mergeInputValues(\n      targetDirective[DirectiveKeys.arguments],\n      sourceDirective[DirectiveKeys.arguments],\n    );\n  }\n}\n\n/**\n * Adds missing definitions from source into target. Mutates target in place.\n */\nexport function mergeTypes(\n  target: TypeDefinitionsRecord,\n  source: TypeDefinitionsRecord,\n): void {\n  for (const [typeName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[typeName];\n    if (!targetDef) {\n      target[typeName] = sourceDef;\n      continue;\n    }\n    if (targetDef[0] === TypeKind.OBJECT && sourceDef[0] === TypeKind.OBJECT) {\n      mergeFields(targetDef[ObjectKeys.fields], sourceDef[ObjectKeys.fields]);\n      // Note: not merging implemented interfaces - assuming they are fully defined by the first occurrence\n      continue;\n    }\n    if (\n      targetDef[0] === TypeKind.INTERFACE &&\n      sourceDef[0] === TypeKind.INTERFACE\n    ) {\n      mergeFields(\n        targetDef[InterfaceKeys.fields],\n        sourceDef[InterfaceKeys.fields],\n      );\n      // Note: not merging implemented interfaces - assuming they are fully defined by the first occurrence\n      continue;\n    }\n    if (targetDef[0] === TypeKind.INPUT && sourceDef[0] === TypeKind.INPUT) {\n      mergeInputValues(\n        targetDef[InputObjectKeys.fields],\n        sourceDef[InputObjectKeys.fields],\n      );\n      continue;\n    }\n    // Note: not merging scalars, unions and enums - assuming they are fully defined by the first occurrence\n    if (targetDef[0] !== sourceDef[0]) {\n      throw new Error(\n        `Type ${typeName} is represented differently in different schema fragments:\\n` +\n          inspect(targetDef) +\n          `\\n` +\n          inspect(sourceDef),\n      );\n    }\n  }\n}\n\nfunction mergeFields(\n  target: FieldDefinitionRecord,\n  source: FieldDefinitionRecord,\n) {\n  for (const [fieldName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[fieldName];\n    if (!target[fieldName] || !Array.isArray(targetDef)) {\n      target[fieldName] = sourceDef;\n      continue;\n    }\n    if (Array.isArray(sourceDef) && sourceDef[FieldKeys.arguments]) {\n      if (!targetDef[FieldKeys.arguments]) {\n        targetDef[FieldKeys.arguments] = {};\n      }\n      mergeInputValues(\n        targetDef[FieldKeys.arguments],\n        sourceDef[FieldKeys.arguments],\n      );\n    }\n  }\n}\n\nfunction mergeInputValues(\n  target: InputValueDefinitionRecord,\n  source: InputValueDefinitionRecord,\n) {\n  for (const [fieldName, sourceDef] of Object.entries(source)) {\n    const targetDef = target[fieldName];\n    if (!target[fieldName] || !Array.isArray(targetDef)) {\n      target[fieldName] = sourceDef;\n    }\n    // Note: not merging defaultValue - assuming it is fully defined by the first occurrence\n  }\n}\n"],
+  "mappings": ";AAAA;AAAA,EAEE;AAAA,EAEA;AAAA,EACA;AAAA,EAEA;AAAA,EACA;AAAA,EAGA;AAAA,OACK;AACP,SAAS,eAAe;AAEjB,SAAS,uBACd,QACA,SACA;AAlBF;AAmBE,MAAI,CAAC,QAAQ,QAAQ;AACnB,WAAO;AAAA,EACT;AACA,aAAW,UAAU,SAAS;AAC5B,QAAI,CAAC,OAAO,OAAO;AACjB,aAAO,QAAQ,OAAO;AAAA,IACxB,WAAW,OAAO,OAAO;AACvB,iBAAW,OAAO,OAAO,OAAO,KAAK;AAAA,IACvC;AACA,QAAI,CAAC,OAAO,YAAY;AACtB,aAAO,aAAa,OAAO;AAAA,IAC7B,YAAW,YAAO,eAAP,mBAAmB,QAAQ;AACpC,sBAAgB,OAAO,YAAY,OAAO,UAAU;AAAA,IACtD;AAAA,EACF;AACF;AAEO,SAAS,gBACd,QACA,QACA;AACA,aAAW,mBAAmB,QAAQ;AACpC,UAAM,kBAAkB,OAAO;AAAA,MAC7B,CAAC,cACC,UAAU,cAAc,IAAI,MAAM,gBAAgB,cAAc,IAAI;AAAA,IACxE;AACA,QAAI,CAAC,iBAAiB;AACpB,aAAO,KAAK,eAAe;AAC3B;AAAA,IACF;AACA,QAAI,CAAC,gBAAgB,cAAc,SAAS,GAAG;AAC7C;AAAA,IACF;AACA,QAAI,CAAC,gBAAgB,cAAc,SAAS,GAAG;AAC7C,sBAAgB,cAAc,SAAS,IACrC,gBAAgB,cAAc,SAAS;AAAA,IAC3C;AACA;AAAA,MACE,gBAAgB,cAAc,SAAS;AAAA,MACvC,gBAAgB,cAAc,SAAS;AAAA,IACzC;AAAA,EACF;AACF;AAKO,SAAS,WACd,QACA,QACM;AACN,aAAW,CAAC,UAAU,SAAS,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC1D,UAAM,YAAY,OAAO,QAAQ;AACjC,QAAI,CAAC,WAAW;AACd,aAAO,QAAQ,IAAI;AACnB;AAAA,IACF;AACA,QAAI,UAAU,CAAC,MAAM,SAAS,UAAU,UAAU,CAAC,MAAM,SAAS,QAAQ;AACxE,kBAAY,UAAU,WAAW,MAAM,GAAG,UAAU,WAAW,MAAM,CAAC;AAEtE;AAAA,IACF;AACA,QACE,UAAU,CAAC,MAAM,SAAS,aAC1B,UAAU,CAAC,MAAM,SAAS,WAC1B;AACA;AAAA,QACE,UAAU,cAAc,MAAM;AAAA,QAC9B,UAAU,cAAc,MAAM;AAAA,MAChC;AAEA;AAAA,IACF;AACA,QAAI,UAAU,CAAC,MAAM,SAAS,SAAS,UAAU,CAAC,MAAM,SAAS,OAAO;AACtE;AAAA,QACE,UAAU,gBAAgB,MAAM;AAAA,QAChC,UAAU,gBAAgB,MAAM;AAAA,MAClC;AACA;AAAA,IACF;AAEA,QAAI,UAAU,CAAC,MAAM,UAAU,CAAC,GAAG;AACjC,YAAM,IAAI;AAAA,QACR,QAAQ;AAAA,IACN,QAAQ,SAAS,IACjB;AAAA,IACA,QAAQ,SAAS;AAAA,MACrB;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,YACP,QACA,QACA;AACA,aAAW,CAAC,WAAW,SAAS,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC3D,UAAM,YAAY,OAAO,SAAS;AAClC,QAAI,CAAC,OAAO,SAAS,KAAK,CAAC,MAAM,QAAQ,SAAS,GAAG;AACnD,aAAO,SAAS,IAAI;AACpB;AAAA,IACF;AACA,QAAI,MAAM,QAAQ,SAAS,KAAK,UAAU,UAAU,SAAS,GAAG;AAC9D,UAAI,CAAC,UAAU,UAAU,SAAS,GAAG;AACnC,kBAAU,UAAU,SAAS,IAAI,CAAC;AAAA,MACpC;AACA;AAAA,QACE,UAAU,UAAU,SAAS;AAAA,QAC7B,UAAU,UAAU,SAAS;AAAA,MAC/B;AAAA,IACF;AAAA,EACF;AACF;AAEA,SAAS,iBACP,QACA,QACA;AACA,aAAW,CAAC,WAAW,SAAS,KAAK,OAAO,QAAQ,MAAM,GAAG;AAC3D,UAAM,YAAY,OAAO,SAAS;AAClC,QAAI,CAAC,OAAO,SAAS,KAAK,CAAC,MAAM,QAAQ,SAAS,GAAG;AACnD,aAAO,SAAS,IAAI;AAAA,IACtB;AAAA,EAEF;AACF;",
+  "names": []
+}

package/lib/utilities/mergeResolvers.d.ts

@@ -1,3 +1,3 @@
 import { UserResolvers, Resolvers } from "../types";
-export declare function mergeResolvers(resolvers: UserResolvers<unknown, unknown>, extractedResolvers: Resolvers): Resolvers;
+export declare function mergeResolvers<TSource, TContext>(resolvers: UserResolvers<TSource, TContext>, extractedResolvers: Resolvers<TSource, TContext>): Resolvers<TSource, TContext>;
 //# sourceMappingURL=mergeResolvers.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"mergeResolvers.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeResolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAY,MAAM,UAAU,CAAC;AAG9D,wBAAgB,cAAc,CAC5B,SAAS,EAAE,aAAa,CAAC,OAAO,EAAE,OAAO,CAAC,EAC1C,kBAAkB,EAAE,SAAS,GAC5B,SAAS,CAoBX"}
+{"version":3,"file":"mergeResolvers.d.ts","sourceRoot":"","sources":["../../src/utilities/mergeResolvers.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,aAAa,EAAE,SAAS,EAAY,MAAM,UAAU,CAAC;AAG9D,wBAAgB,cAAc,CAAC,OAAO,EAAE,QAAQ,EAC9C,SAAS,EAAE,aAAa,CAAC,OAAO,EAAE,QAAQ,CAAC,EAC3C,kBAAkB,EAAE,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,GAC/C,SAAS,CAAC,OAAO,EAAE,QAAQ,CAAC,CAoB9B"}

package/lib/utilities/mergeResolvers.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utilities/mergeResolvers.ts"],
-  "sourcesContent": ["import { UserResolvers, Resolvers, Resolver } from \"../types\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\n\nexport function mergeResolvers(\n  resolvers: UserResolvers<unknown, unknown>,\n  extractedResolvers: Resolvers,\n): Resolvers {\n  const fullResolvers = {\n    ...extractedResolvers,\n  } as Resolvers;\n\n  Object.keys(resolvers).forEach((resolverKey: string) => {\n    if (isObjectLike(fullResolvers[resolverKey])) {\n      fullResolvers[resolverKey] = {\n        ...fullResolvers[resolverKey],\n        ...resolvers[resolverKey],\n      } as Resolver<unknown, unknown>;\n    } else {\n      fullResolvers[resolverKey] = resolvers[resolverKey] as Resolver<\n        unknown,\n        unknown\n      >;\n    }\n  });\n\n  return fullResolvers;\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,0BAA6B;AAEtB,SAAS,eACd,WACA,oBACW;AACX,QAAM,gBAAgB,mBACjB;AAGL,SAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,gBAAwB;AACtD,YAAI,kCAAa,cAAc,WAAW,CAAC,GAAG;AAC5C,oBAAc,WAAW,IAAI,kCACxB,cAAc,WAAW,IACzB,UAAU,WAAW;AAAA,IAE5B,OAAO;AACL,oBAAc,WAAW,IAAI,UAAU,WAAW;AAAA,IAIpD;AAAA,EACF,CAAC;AAED,SAAO;AACT;",
+  "sourcesContent": ["import { UserResolvers, Resolvers, Resolver } from \"../types\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\n\nexport function mergeResolvers<TSource, TContext>(\n  resolvers: UserResolvers<TSource, TContext>,\n  extractedResolvers: Resolvers<TSource, TContext>,\n): Resolvers<TSource, TContext> {\n  const fullResolvers = {\n    ...extractedResolvers,\n  } as Resolvers<TSource, TContext>;\n\n  Object.keys(resolvers).forEach((resolverKey: string) => {\n    if (isObjectLike(fullResolvers[resolverKey])) {\n      fullResolvers[resolverKey] = {\n        ...fullResolvers[resolverKey],\n        ...resolvers[resolverKey],\n      } as Resolver<unknown, unknown>;\n    } else {\n      fullResolvers[resolverKey] = resolvers[resolverKey] as Resolver<\n        TSource,\n        TContext\n      >;\n    }\n  });\n\n  return fullResolvers;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AACA,0BAA6B;AAEtB,SAAS,eACd,WACA,oBAC8B;AAC9B,QAAM,gBAAgB,mBACjB;AAGL,SAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,gBAAwB;AACtD,YAAI,kCAAa,cAAc,WAAW,CAAC,GAAG;AAC5C,oBAAc,WAAW,IAAI,kCACxB,cAAc,WAAW,IACzB,UAAU,WAAW;AAAA,IAE5B,OAAO;AACL,oBAAc,WAAW,IAAI,UAAU,WAAW;AAAA,IAIpD;AAAA,EACF,CAAC;AAED,SAAO;AACT;",
   "names": []
 }

package/lib/utilities/mergeResolvers.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utilities/mergeResolvers.ts"],
-  "sourcesContent": ["import { UserResolvers, Resolvers, Resolver } from \"../types\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\n\nexport function mergeResolvers(\n  resolvers: UserResolvers<unknown, unknown>,\n  extractedResolvers: Resolvers,\n): Resolvers {\n  const fullResolvers = {\n    ...extractedResolvers,\n  } as Resolvers;\n\n  Object.keys(resolvers).forEach((resolverKey: string) => {\n    if (isObjectLike(fullResolvers[resolverKey])) {\n      fullResolvers[resolverKey] = {\n        ...fullResolvers[resolverKey],\n        ...resolvers[resolverKey],\n      } as Resolver<unknown, unknown>;\n    } else {\n      fullResolvers[resolverKey] = resolvers[resolverKey] as Resolver<\n        unknown,\n        unknown\n      >;\n    }\n  });\n\n  return fullResolvers;\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AACA,SAAS,oBAAoB;AAEtB,SAAS,eACd,WACA,oBACW;AACX,QAAM,gBAAgB,mBACjB;AAGL,SAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,gBAAwB;AACtD,QAAI,aAAa,cAAc,WAAW,CAAC,GAAG;AAC5C,oBAAc,WAAW,IAAI,kCACxB,cAAc,WAAW,IACzB,UAAU,WAAW;AAAA,IAE5B,OAAO;AACL,oBAAc,WAAW,IAAI,UAAU,WAAW;AAAA,IAIpD;AAAA,EACF,CAAC;AAED,SAAO;AACT;",
+  "sourcesContent": ["import { UserResolvers, Resolvers, Resolver } from \"../types\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\n\nexport function mergeResolvers<TSource, TContext>(\n  resolvers: UserResolvers<TSource, TContext>,\n  extractedResolvers: Resolvers<TSource, TContext>,\n): Resolvers<TSource, TContext> {\n  const fullResolvers = {\n    ...extractedResolvers,\n  } as Resolvers<TSource, TContext>;\n\n  Object.keys(resolvers).forEach((resolverKey: string) => {\n    if (isObjectLike(fullResolvers[resolverKey])) {\n      fullResolvers[resolverKey] = {\n        ...fullResolvers[resolverKey],\n        ...resolvers[resolverKey],\n      } as Resolver<unknown, unknown>;\n    } else {\n      fullResolvers[resolverKey] = resolvers[resolverKey] as Resolver<\n        TSource,\n        TContext\n      >;\n    }\n  });\n\n  return fullResolvers;\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AACA,SAAS,oBAAoB;AAEtB,SAAS,eACd,WACA,oBAC8B;AAC9B,QAAM,gBAAgB,mBACjB;AAGL,SAAO,KAAK,SAAS,EAAE,QAAQ,CAAC,gBAAwB;AACtD,QAAI,aAAa,cAAc,WAAW,CAAC,GAAG;AAC5C,oBAAc,WAAW,IAAI,kCACxB,cAAc,WAAW,IACzB,UAAU,WAAW;AAAA,IAE5B,OAAO;AACL,oBAAc,WAAW,IAAI,UAAU,WAAW;AAAA,IAIpD;AAAA,EACF,CAAC;AAED,SAAO;AACT;",
   "names": []
 }

package/lib/utilities/typeNameFromAST.d.ts

@@ -1,3 +1,3 @@
-import { TypeNode } from "@graphitation/supermassive-ast";
+import { TypeNode } from "graphql";
 export declare function typeNameFromAST(typeAst: TypeNode): string;
 //# sourceMappingURL=typeNameFromAST.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"typeNameFromAST.d.ts","sourceRoot":"","sources":["../../src/utilities/typeNameFromAST.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,QAAQ,EAAE,MAAM,gCAAgC,CAAC;AAE1D,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAMzD"}
+{"version":3,"file":"typeNameFromAST.d.ts","sourceRoot":"","sources":["../../src/utilities/typeNameFromAST.ts"],"names":[],"mappings":"AAAA,OAAO,EAAQ,QAAQ,EAAE,MAAM,SAAS,CAAC;AAEzC,wBAAgB,eAAe,CAAC,OAAO,EAAE,QAAQ,GAAG,MAAM,CAMzD"}

package/lib/utilities/typeNameFromAST.js.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utilities/typeNameFromAST.ts"],
-  "sourcesContent": ["import { Kind } from \"graphql\";\nimport { TypeNode } from \"@graphitation/supermassive-ast\";\n\nexport function typeNameFromAST(typeAst: TypeNode): string {\n  if (typeAst.kind === Kind.LIST_TYPE || typeAst.kind === Kind.NON_NULL_TYPE) {\n    return typeNameFromAST(typeAst.type);\n  } else {\n    return typeAst.name.value;\n  }\n}\n"],
-  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAAqB;AAGd,SAAS,gBAAgB,SAA2B;AACzD,MAAI,QAAQ,SAAS,oBAAK,aAAa,QAAQ,SAAS,oBAAK,eAAe;AAC1E,WAAO,gBAAgB,QAAQ,IAAI;AAAA,EACrC,OAAO;AACL,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;",
+  "sourcesContent": ["import { Kind, TypeNode } from \"graphql\";\n\nexport function typeNameFromAST(typeAst: TypeNode): string {\n  if (typeAst.kind === Kind.LIST_TYPE || typeAst.kind === Kind.NON_NULL_TYPE) {\n    return typeNameFromAST(typeAst.type);\n  } else {\n    return typeAst.name.value;\n  }\n}\n"],
+  "mappings": ";;;;;;;;;;;;;;;;;;AAAA;AAAA;AAAA;AAAA;AAAA;AAAA,qBAA+B;AAExB,SAAS,gBAAgB,SAA2B;AACzD,MAAI,QAAQ,SAAS,oBAAK,aAAa,QAAQ,SAAS,oBAAK,eAAe;AAC1E,WAAO,gBAAgB,QAAQ,IAAI;AAAA,EACrC,OAAO;AACL,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;",
   "names": []
 }

package/lib/utilities/typeNameFromAST.mjs.map

@@ -1,7 +1,7 @@
 {
   "version": 3,
   "sources": ["../../src/utilities/typeNameFromAST.ts"],
-  "sourcesContent": ["import { Kind } from \"graphql\";\nimport { TypeNode } from \"@graphitation/supermassive-ast\";\n\nexport function typeNameFromAST(typeAst: TypeNode): string {\n  if (typeAst.kind === Kind.LIST_TYPE || typeAst.kind === Kind.NON_NULL_TYPE) {\n    return typeNameFromAST(typeAst.type);\n  } else {\n    return typeAst.name.value;\n  }\n}\n"],
-  "mappings": ";AAAA,SAAS,YAAY;AAGd,SAAS,gBAAgB,SAA2B;AACzD,MAAI,QAAQ,SAAS,KAAK,aAAa,QAAQ,SAAS,KAAK,eAAe;AAC1E,WAAO,gBAAgB,QAAQ,IAAI;AAAA,EACrC,OAAO;AACL,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;",
+  "sourcesContent": ["import { Kind, TypeNode } from \"graphql\";\n\nexport function typeNameFromAST(typeAst: TypeNode): string {\n  if (typeAst.kind === Kind.LIST_TYPE || typeAst.kind === Kind.NON_NULL_TYPE) {\n    return typeNameFromAST(typeAst.type);\n  } else {\n    return typeAst.name.value;\n  }\n}\n"],
+  "mappings": ";AAAA,SAAS,YAAsB;AAExB,SAAS,gBAAgB,SAA2B;AACzD,MAAI,QAAQ,SAAS,KAAK,aAAa,QAAQ,SAAS,KAAK,eAAe;AAC1E,WAAO,gBAAgB,QAAQ,IAAI;AAAA,EACrC,OAAO;AACL,WAAO,QAAQ,KAAK;AAAA,EACtB;AACF;",
   "names": []
 }

package/lib/utilities/valueFromAST.d.ts

@@ -0,0 +1,27 @@
+import type { Maybe } from "../jsutils/Maybe";
+import type { ObjMap } from "../jsutils/ObjMap";
+import { TypeReference } from "../schema/definition";
+import { SchemaFragment } from "../schema/fragment";
+import { ValueNode } from "graphql";
+/**
+ * Produces a JavaScript value given a GraphQL Value AST.
+ *
+ * A GraphQL type must be provided, which will be used to interpret different
+ * GraphQL Value literals.
+ *
+ * Returns `undefined` when the value could not be validly coerced according to
+ * the provided type.
+ *
+ * | GraphQL Value        | JSON Value    |
+ * | -------------------- | ------------- |
+ * | Input Object         | Object        |
+ * | List                 | Array         |
+ * | Boolean              | Boolean       |
+ * | String               | String        |
+ * | Int / Float          | Number        |
+ * | Enum Value           | Unknown       |
+ * | NullValue            | null          |
+ *
+ */
+export declare function valueFromAST(valueNode: Maybe<ValueNode>, typeRef: TypeReference, schemaTypes: SchemaFragment, variables?: Maybe<ObjMap<unknown>>): unknown;
+//# sourceMappingURL=valueFromAST.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"valueFromAST.d.ts","sourceRoot":"","sources":["../../src/utilities/valueFromAST.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,kBAAkB,CAAC;AAC9C,OAAO,KAAK,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAEhD,OAAO,EAAE,aAAa,EAAE,MAAM,sBAAsB,CAAC;AACrD,OAAO,EAAE,cAAc,EAAE,MAAM,oBAAoB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAQ,MAAM,SAAS,CAAC;AAQ1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,YAAY,CAC1B,SAAS,EAAE,KAAK,CAAC,SAAS,CAAC,EAC3B,OAAO,EAAE,aAAa,EACtB,WAAW,EAAE,cAAc,EAC3B,SAAS,CAAC,EAAE,KAAK,CAAC,MAAM,CAAC,OAAO,CAAC,CAAC,GACjC,OAAO,CAmIT"}

package/lib/utilities/valueFromAST.js

@@ -0,0 +1,139 @@
+"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 valueFromAST_exports = {};
+__export(valueFromAST_exports, {
+  valueFromAST: () => valueFromAST
+});
+module.exports = __toCommonJS(valueFromAST_exports);
+var import_invariant = require("../jsutils/invariant");
+var import_graphql = require("graphql");
+var import_reference = require("../schema/reference");
+function valueFromAST(valueNode, typeRef, schemaTypes, variables) {
+  if (!valueNode) {
+    return;
+  }
+  if (valueNode.kind === import_graphql.Kind.VARIABLE) {
+    const variableName = valueNode.name.value;
+    if (variables == null || variables[variableName] === void 0) {
+      return;
+    }
+    const variableValue = variables[variableName];
+    if (variableValue === null && (0, import_reference.isNonNullType)(typeRef)) {
+      return;
+    }
+    return variableValue;
+  }
+  if ((0, import_reference.isNonNullType)(typeRef)) {
+    if (valueNode.kind === import_graphql.Kind.NULL) {
+      return;
+    }
+    return valueFromAST(valueNode, (0, import_reference.unwrap)(typeRef), schemaTypes, variables);
+  }
+  if (valueNode.kind === import_graphql.Kind.NULL) {
+    return null;
+  }
+  if ((0, import_reference.isListType)(typeRef)) {
+    const itemTypeRef = (0, import_reference.unwrap)(typeRef);
+    if (valueNode.kind === import_graphql.Kind.LIST) {
+      const coercedValues = [];
+      for (const itemNode of valueNode.values) {
+        if (isMissingVariable(itemNode, variables)) {
+          if ((0, import_reference.isNonNullType)(itemTypeRef)) {
+            return;
+          }
+          coercedValues.push(null);
+        } else {
+          const itemValue = valueFromAST(
+            itemNode,
+            itemTypeRef,
+            schemaTypes,
+            variables
+          );
+          if (itemValue === void 0) {
+            return;
+          }
+          coercedValues.push(itemValue);
+        }
+      }
+      return coercedValues;
+    }
+    const coercedValue = valueFromAST(
+      valueNode,
+      itemTypeRef,
+      schemaTypes,
+      variables
+    );
+    if (coercedValue === void 0) {
+      return;
+    }
+    return [coercedValue];
+  }
+  const inputObjectType = schemaTypes.getInputObjectType(typeRef);
+  if (inputObjectType) {
+    if (valueNode.kind !== import_graphql.Kind.OBJECT) {
+      return;
+    }
+    const coercedObj = /* @__PURE__ */ Object.create(null);
+    const fieldNodes = new Map(
+      valueNode.fields.map((field) => [field.name.value, field])
+    );
+    const fieldDefs = schemaTypes.getInputObjectFields(inputObjectType);
+    for (const [name, field] of Object.entries(fieldDefs)) {
+      const fieldNode = fieldNodes.get(name);
+      const fieldTypeRef = schemaTypes.getTypeReference(field);
+      if (fieldNode == null || isMissingVariable(fieldNode.value, variables)) {
+        const defaultValue = schemaTypes.getInputDefaultValue(field);
+        if (defaultValue !== void 0) {
+          coercedObj[name] = defaultValue;
+        } else if ((0, import_reference.isNonNullType)(fieldTypeRef)) {
+          return;
+        }
+        continue;
+      }
+      const fieldValue = valueFromAST(
+        fieldNode.value,
+        fieldTypeRef,
+        schemaTypes,
+        variables
+      );
+      if (fieldValue === void 0) {
+        return;
+      }
+      coercedObj[name] = fieldValue;
+    }
+    return coercedObj;
+  }
+  const leafType = schemaTypes.getLeafTypeResolver(typeRef);
+  if (leafType) {
+    let result;
+    try {
+      result = leafType.parseLiteral(valueNode, variables);
+    } catch (_error) {
+      return;
+    }
+    if (result === void 0) {
+      return;
+    }
+    return result;
+  }
+  (0, import_invariant.invariant)(false, "Unexpected input type: " + (0, import_reference.inspectTypeReference)(typeRef));
+}
+function isMissingVariable(valueNode, variables) {
+  return valueNode.kind === import_graphql.Kind.VARIABLE && (variables == null || variables[valueNode.name.value] === void 0);
+}