@graphitation/supermassive 2.6.1 → 3.0.0-alpha.3

package/lib/utilities/coerceInputValue.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/coerceInputValue.ts"],
+  "sourcesContent": ["import { GraphQLError } from \"graphql\";\nimport { didYouMean } from \"../jsutils/didYouMean\";\nimport { inspect } from \"../jsutils/inspect\";\nimport { invariant } from \"../jsutils/invariant\";\nimport { isIterableObject } from \"../jsutils/isIterableObject\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\nimport type { Path } from \"../jsutils/Path\";\nimport { addPath, pathToArray } from \"../jsutils/Path\";\nimport { printPathArray } from \"../jsutils/printPathArray\";\nimport { suggestionList } from \"../jsutils/suggestionList\";\nimport { TypeReference } from \"../schema/definition\";\nimport { SchemaFragment } from \"../schema/fragment\";\nimport {\n  inspectTypeReference,\n  isListType,\n  isNonNullType,\n  unwrap,\n} from \"../schema/reference\";\n\ntype OnErrorCB = (\n  path: ReadonlyArray<string | number>,\n  invalidValue: unknown,\n  error: GraphQLError,\n) => void;\n\n/**\n * Coerces a JavaScript value given a GraphQL Input Type.\n */\nexport function coerceInputValue(\n  inputValue: unknown,\n  typeRef: TypeReference,\n  schemaTypes: SchemaFragment,\n  onError: OnErrorCB = defaultOnError,\n): unknown {\n  return coerceInputValueImpl(\n    inputValue,\n    typeRef,\n    schemaTypes,\n    onError,\n    undefined,\n  );\n}\n\nfunction defaultOnError(\n  path: ReadonlyArray<string | number>,\n  invalidValue: unknown,\n  error: GraphQLError,\n): void {\n  let errorPrefix = \"Invalid value \" + inspect(invalidValue);\n  if (path.length > 0) {\n    errorPrefix += ` at \"value${printPathArray(path)}\"`;\n  }\n  error.message = errorPrefix + \": \" + error.message;\n  throw error;\n}\n\nfunction coerceInputValueImpl(\n  inputValue: unknown,\n  typeRef: TypeReference,\n  schemaTypes: SchemaFragment,\n  onError: OnErrorCB,\n  path: Path | undefined,\n): unknown {\n  if (isNonNullType(typeRef)) {\n    if (inputValue != null) {\n      return coerceInputValueImpl(\n        inputValue,\n        unwrap(typeRef),\n        schemaTypes,\n        onError,\n        path,\n      );\n    }\n    onError(\n      pathToArray(path),\n      inputValue,\n      new GraphQLError(\n        `Expected non-nullable type \"${inspectTypeReference(\n          typeRef,\n        )}\" not to be null.`,\n      ),\n    );\n    return;\n  }\n\n  if (inputValue == null) {\n    // Explicitly return the value null.\n    return null;\n  }\n\n  if (isListType(typeRef)) {\n    const itemType = unwrap(typeRef);\n    if (isIterableObject(inputValue)) {\n      return Array.from(inputValue, (itemValue, index) => {\n        const itemPath = addPath(path, index, undefined);\n        return coerceInputValueImpl(\n          itemValue,\n          itemType,\n          schemaTypes,\n          onError,\n          itemPath,\n        );\n      });\n    }\n    // Lists accept a non-list value as a list of one.\n    return [\n      coerceInputValueImpl(inputValue, itemType, schemaTypes, onError, path),\n    ];\n  }\n\n  const inputObjectType = schemaTypes.getInputObjectType(typeRef);\n  if (inputObjectType) {\n    const typeName = inspectTypeReference(typeRef);\n    if (!isObjectLike(inputValue)) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${typeRef}\" to be an object.`),\n      );\n      return;\n    }\n\n    const coercedValue: Record<string, unknown> = {};\n    const fieldDefs = schemaTypes.getInputObjectFields(inputObjectType);\n\n    for (const [fieldName, field] of Object.entries(fieldDefs)) {\n      const fieldValue = inputValue[fieldName];\n      const defaultValue = schemaTypes.getInputDefaultValue(field);\n      const fieldTypeRef = schemaTypes.getTypeReference(field);\n\n      if (fieldValue === undefined) {\n        if (defaultValue !== undefined) {\n          coercedValue[fieldName] = defaultValue;\n        } else if (isNonNullType(fieldTypeRef)) {\n          const typeStr = inspectTypeReference(fieldTypeRef);\n          onError(\n            pathToArray(path),\n            inputValue,\n            new GraphQLError(\n              `Field \"${fieldName}\" of required type \"${typeStr}\" was not provided.`,\n            ),\n          );\n        }\n        continue;\n      }\n\n      coercedValue[fieldName] = coerceInputValueImpl(\n        fieldValue,\n        fieldTypeRef,\n        schemaTypes,\n        onError,\n        addPath(path, fieldName, typeName),\n      );\n    }\n\n    // Ensure every provided field is defined.\n    for (const fieldName of Object.keys(inputValue)) {\n      if (fieldDefs[fieldName] == null) {\n        const suggestions = suggestionList(fieldName, Object.keys(fieldDefs));\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(\n            `Field \"${fieldName}\" is not defined by type \"${typeName}\".` +\n              didYouMean(suggestions),\n          ),\n        );\n      }\n    }\n    return coercedValue;\n  }\n\n  const leafType = schemaTypes.getLeafTypeResolver(typeRef);\n  if (leafType) {\n    let parseResult;\n\n    // Scalars and Enums determine if an input value is valid via parseValue(),\n    // which can throw to indicate failure. If it throws, maintain a reference\n    // to the original error.\n    try {\n      parseResult = leafType.parseValue(inputValue);\n    } catch (error) {\n      if (error instanceof GraphQLError) {\n        onError(pathToArray(path), inputValue, error);\n      } else {\n        const typeName = inspectTypeReference(typeRef);\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(\n            `Expected type \"${typeName}\". ` + (error as Error).message,\n            {\n              originalError: error as Error,\n            },\n          ),\n        );\n      }\n      return;\n    }\n    if (parseResult === undefined) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${inspectTypeReference(typeRef)}\".`),\n      );\n    }\n    return parseResult;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible types have been considered.\n  invariant(false, \"Unexpected input type: \" + inspectTypeReference(typeRef));\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/utilities/coerceInputValue.mjs

@@ -0,0 +1,167 @@
+// src/utilities/coerceInputValue.ts
+import { GraphQLError } from "graphql";
+import { didYouMean } from "../jsutils/didYouMean.mjs";
+import { inspect } from "../jsutils/inspect.mjs";
+import { invariant } from "../jsutils/invariant.mjs";
+import { isIterableObject } from "../jsutils/isIterableObject.mjs";
+import { isObjectLike } from "../jsutils/isObjectLike.mjs";
+import { addPath, pathToArray } from "../jsutils/Path.mjs";
+import { printPathArray } from "../jsutils/printPathArray.mjs";
+import { suggestionList } from "../jsutils/suggestionList.mjs";
+import {
+  inspectTypeReference,
+  isListType,
+  isNonNullType,
+  unwrap
+} from "../schema/reference.mjs";
+function coerceInputValue(inputValue, typeRef, schemaTypes, onError = defaultOnError) {
+  return coerceInputValueImpl(
+    inputValue,
+    typeRef,
+    schemaTypes,
+    onError,
+    void 0
+  );
+}
+function defaultOnError(path, invalidValue, error) {
+  let errorPrefix = "Invalid value " + inspect(invalidValue);
+  if (path.length > 0) {
+    errorPrefix += ` at "value${printPathArray(path)}"`;
+  }
+  error.message = errorPrefix + ": " + error.message;
+  throw error;
+}
+function coerceInputValueImpl(inputValue, typeRef, schemaTypes, onError, path) {
+  if (isNonNullType(typeRef)) {
+    if (inputValue != null) {
+      return coerceInputValueImpl(
+        inputValue,
+        unwrap(typeRef),
+        schemaTypes,
+        onError,
+        path
+      );
+    }
+    onError(
+      pathToArray(path),
+      inputValue,
+      new GraphQLError(
+        `Expected non-nullable type "${inspectTypeReference(
+          typeRef
+        )}" not to be null.`
+      )
+    );
+    return;
+  }
+  if (inputValue == null) {
+    return null;
+  }
+  if (isListType(typeRef)) {
+    const itemType = unwrap(typeRef);
+    if (isIterableObject(inputValue)) {
+      return Array.from(inputValue, (itemValue, index) => {
+        const itemPath = 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 = inspectTypeReference(typeRef);
+    if (!isObjectLike(inputValue)) {
+      onError(
+        pathToArray(path),
+        inputValue,
+        new 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 (isNonNullType(fieldTypeRef)) {
+          const typeStr = inspectTypeReference(fieldTypeRef);
+          onError(
+            pathToArray(path),
+            inputValue,
+            new GraphQLError(
+              `Field "${fieldName}" of required type "${typeStr}" was not provided.`
+            )
+          );
+        }
+        continue;
+      }
+      coercedValue[fieldName] = coerceInputValueImpl(
+        fieldValue,
+        fieldTypeRef,
+        schemaTypes,
+        onError,
+        addPath(path, fieldName, typeName)
+      );
+    }
+    for (const fieldName of Object.keys(inputValue)) {
+      if (fieldDefs[fieldName] == null) {
+        const suggestions = suggestionList(fieldName, Object.keys(fieldDefs));
+        onError(
+          pathToArray(path),
+          inputValue,
+          new GraphQLError(
+            `Field "${fieldName}" is not defined by type "${typeName}".` + didYouMean(suggestions)
+          )
+        );
+      }
+    }
+    return coercedValue;
+  }
+  const leafType = schemaTypes.getLeafTypeResolver(typeRef);
+  if (leafType) {
+    let parseResult;
+    try {
+      parseResult = leafType.parseValue(inputValue);
+    } catch (error) {
+      if (error instanceof GraphQLError) {
+        onError(pathToArray(path), inputValue, error);
+      } else {
+        const typeName = inspectTypeReference(typeRef);
+        onError(
+          pathToArray(path),
+          inputValue,
+          new GraphQLError(
+            `Expected type "${typeName}". ` + error.message,
+            {
+              originalError: error
+            }
+          )
+        );
+      }
+      return;
+    }
+    if (parseResult === void 0) {
+      onError(
+        pathToArray(path),
+        inputValue,
+        new GraphQLError(`Expected type "${inspectTypeReference(typeRef)}".`)
+      );
+    }
+    return parseResult;
+  }
+  invariant(false, "Unexpected input type: " + inspectTypeReference(typeRef));
+}
+export {
+  coerceInputValue
+};

package/lib/utilities/coerceInputValue.mjs.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/coerceInputValue.ts"],
+  "sourcesContent": ["import { GraphQLError } from \"graphql\";\nimport { didYouMean } from \"../jsutils/didYouMean\";\nimport { inspect } from \"../jsutils/inspect\";\nimport { invariant } from \"../jsutils/invariant\";\nimport { isIterableObject } from \"../jsutils/isIterableObject\";\nimport { isObjectLike } from \"../jsutils/isObjectLike\";\nimport type { Path } from \"../jsutils/Path\";\nimport { addPath, pathToArray } from \"../jsutils/Path\";\nimport { printPathArray } from \"../jsutils/printPathArray\";\nimport { suggestionList } from \"../jsutils/suggestionList\";\nimport { TypeReference } from \"../schema/definition\";\nimport { SchemaFragment } from \"../schema/fragment\";\nimport {\n  inspectTypeReference,\n  isListType,\n  isNonNullType,\n  unwrap,\n} from \"../schema/reference\";\n\ntype OnErrorCB = (\n  path: ReadonlyArray<string | number>,\n  invalidValue: unknown,\n  error: GraphQLError,\n) => void;\n\n/**\n * Coerces a JavaScript value given a GraphQL Input Type.\n */\nexport function coerceInputValue(\n  inputValue: unknown,\n  typeRef: TypeReference,\n  schemaTypes: SchemaFragment,\n  onError: OnErrorCB = defaultOnError,\n): unknown {\n  return coerceInputValueImpl(\n    inputValue,\n    typeRef,\n    schemaTypes,\n    onError,\n    undefined,\n  );\n}\n\nfunction defaultOnError(\n  path: ReadonlyArray<string | number>,\n  invalidValue: unknown,\n  error: GraphQLError,\n): void {\n  let errorPrefix = \"Invalid value \" + inspect(invalidValue);\n  if (path.length > 0) {\n    errorPrefix += ` at \"value${printPathArray(path)}\"`;\n  }\n  error.message = errorPrefix + \": \" + error.message;\n  throw error;\n}\n\nfunction coerceInputValueImpl(\n  inputValue: unknown,\n  typeRef: TypeReference,\n  schemaTypes: SchemaFragment,\n  onError: OnErrorCB,\n  path: Path | undefined,\n): unknown {\n  if (isNonNullType(typeRef)) {\n    if (inputValue != null) {\n      return coerceInputValueImpl(\n        inputValue,\n        unwrap(typeRef),\n        schemaTypes,\n        onError,\n        path,\n      );\n    }\n    onError(\n      pathToArray(path),\n      inputValue,\n      new GraphQLError(\n        `Expected non-nullable type \"${inspectTypeReference(\n          typeRef,\n        )}\" not to be null.`,\n      ),\n    );\n    return;\n  }\n\n  if (inputValue == null) {\n    // Explicitly return the value null.\n    return null;\n  }\n\n  if (isListType(typeRef)) {\n    const itemType = unwrap(typeRef);\n    if (isIterableObject(inputValue)) {\n      return Array.from(inputValue, (itemValue, index) => {\n        const itemPath = addPath(path, index, undefined);\n        return coerceInputValueImpl(\n          itemValue,\n          itemType,\n          schemaTypes,\n          onError,\n          itemPath,\n        );\n      });\n    }\n    // Lists accept a non-list value as a list of one.\n    return [\n      coerceInputValueImpl(inputValue, itemType, schemaTypes, onError, path),\n    ];\n  }\n\n  const inputObjectType = schemaTypes.getInputObjectType(typeRef);\n  if (inputObjectType) {\n    const typeName = inspectTypeReference(typeRef);\n    if (!isObjectLike(inputValue)) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${typeRef}\" to be an object.`),\n      );\n      return;\n    }\n\n    const coercedValue: Record<string, unknown> = {};\n    const fieldDefs = schemaTypes.getInputObjectFields(inputObjectType);\n\n    for (const [fieldName, field] of Object.entries(fieldDefs)) {\n      const fieldValue = inputValue[fieldName];\n      const defaultValue = schemaTypes.getInputDefaultValue(field);\n      const fieldTypeRef = schemaTypes.getTypeReference(field);\n\n      if (fieldValue === undefined) {\n        if (defaultValue !== undefined) {\n          coercedValue[fieldName] = defaultValue;\n        } else if (isNonNullType(fieldTypeRef)) {\n          const typeStr = inspectTypeReference(fieldTypeRef);\n          onError(\n            pathToArray(path),\n            inputValue,\n            new GraphQLError(\n              `Field \"${fieldName}\" of required type \"${typeStr}\" was not provided.`,\n            ),\n          );\n        }\n        continue;\n      }\n\n      coercedValue[fieldName] = coerceInputValueImpl(\n        fieldValue,\n        fieldTypeRef,\n        schemaTypes,\n        onError,\n        addPath(path, fieldName, typeName),\n      );\n    }\n\n    // Ensure every provided field is defined.\n    for (const fieldName of Object.keys(inputValue)) {\n      if (fieldDefs[fieldName] == null) {\n        const suggestions = suggestionList(fieldName, Object.keys(fieldDefs));\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(\n            `Field \"${fieldName}\" is not defined by type \"${typeName}\".` +\n              didYouMean(suggestions),\n          ),\n        );\n      }\n    }\n    return coercedValue;\n  }\n\n  const leafType = schemaTypes.getLeafTypeResolver(typeRef);\n  if (leafType) {\n    let parseResult;\n\n    // Scalars and Enums determine if an input value is valid via parseValue(),\n    // which can throw to indicate failure. If it throws, maintain a reference\n    // to the original error.\n    try {\n      parseResult = leafType.parseValue(inputValue);\n    } catch (error) {\n      if (error instanceof GraphQLError) {\n        onError(pathToArray(path), inputValue, error);\n      } else {\n        const typeName = inspectTypeReference(typeRef);\n        onError(\n          pathToArray(path),\n          inputValue,\n          new GraphQLError(\n            `Expected type \"${typeName}\". ` + (error as Error).message,\n            {\n              originalError: error as Error,\n            },\n          ),\n        );\n      }\n      return;\n    }\n    if (parseResult === undefined) {\n      onError(\n        pathToArray(path),\n        inputValue,\n        new GraphQLError(`Expected type \"${inspectTypeReference(typeRef)}\".`),\n      );\n    }\n    return parseResult;\n  }\n  /* c8 ignore next 3 */\n  // Not reachable, all possible types have been considered.\n  invariant(false, \"Unexpected input type: \" + inspectTypeReference(typeRef));\n}\n"],
+  "mappings": "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",
+  "names": []
+}

package/lib/utilities/decodeASTSchema.d.ts

@@ -0,0 +1,7 @@
+import { DocumentNode } from "graphql";
+import { SchemaFragmentDefinitions } from "../schema/definition";
+/**
+ * Converts encoded schema to standard AST representation of the same schema
+ */
+export declare function decodeSchema(encodedSchema: SchemaFragmentDefinitions): DocumentNode;
+//# sourceMappingURL=decodeASTSchema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"decodeASTSchema.d.ts","sourceRoot":"","sources":["../../src/utilities/decodeASTSchema.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,YAAY,EAcb,MAAM,SAAS,CAAC;AAEjB,OAAO,EAGL,yBAAyB,EAkB1B,MAAM,sBAAsB,CAAC;AAY9B;;GAEG;AACH,wBAAgB,YAAY,CAC1B,aAAa,EAAE,yBAAyB,GACvC,YAAY,CAiCd"}

package/lib/utilities/decodeASTSchema.js

@@ -0,0 +1,243 @@
+"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 decodeASTSchema_exports = {};
+__export(decodeASTSchema_exports, {
+  decodeSchema: () => decodeSchema
+});
+module.exports = __toCommonJS(decodeASTSchema_exports);
+var import_graphql = require("graphql");
+var import_definition = require("../schema/definition");
+var import_reference = require("../schema/reference");
+var import_invariant = require("../jsutils/invariant");
+var import_inspect = require("../jsutils/inspect");
+function decodeSchema(encodedSchema) {
+  var _a;
+  const definitions = [];
+  const types = encodedSchema.types;
+  for (const typeName in types) {
+    const tuple = types[typeName];
+    switch (tuple[0]) {
+      case import_definition.TypeKind.SCALAR:
+        definitions.push(decodeScalarType(typeName));
+        break;
+      case import_definition.TypeKind.ENUM:
+        definitions.push(decodeEnumType(typeName, tuple));
+        break;
+      case import_definition.TypeKind.OBJECT:
+        definitions.push(decodeObjectType(typeName, tuple, types));
+        break;
+      case import_definition.TypeKind.INTERFACE:
+        definitions.push(decodeInterfaceType(typeName, tuple, types));
+        break;
+      case import_definition.TypeKind.UNION:
+        definitions.push(decodeUnionType(typeName, tuple));
+        break;
+      case import_definition.TypeKind.INPUT:
+        definitions.push(decodeInputObjectType(typeName, tuple, types));
+        break;
+    }
+  }
+  for (const directive of (_a = encodedSchema.directives) != null ? _a : []) {
+    definitions.push(decodeDirective(directive, types));
+  }
+  return { kind: import_graphql.Kind.DOCUMENT, definitions };
+}
+function nameNode(value) {
+  return { kind: import_graphql.Kind.NAME, value };
+}
+function decodeScalarType(typeName) {
+  return {
+    kind: import_graphql.Kind.SCALAR_TYPE_DEFINITION,
+    name: nameNode(typeName)
+  };
+}
+function decodeEnumType(typeName, tuple) {
+  return {
+    kind: import_graphql.Kind.ENUM_TYPE_DEFINITION,
+    name: nameNode(typeName),
+    values: tuple[import_definition.EnumKeys.values].map((value) => ({
+      kind: import_graphql.Kind.ENUM_VALUE_DEFINITION,
+      name: nameNode(value)
+    }))
+  };
+}
+function decodeObjectType(typeName, tuple, types) {
+  return {
+    kind: import_graphql.Kind.OBJECT_TYPE_DEFINITION,
+    name: nameNode(typeName),
+    fields: decodeFields(tuple[import_definition.ObjectKeys.fields], types),
+    interfaces: (tuple[import_definition.ObjectKeys.interfaces] || []).map((name) => ({
+      kind: import_graphql.Kind.NAMED_TYPE,
+      name: nameNode(name)
+    }))
+  };
+}
+function decodeInterfaceType(typeName, tuple, types) {
+  return {
+    kind: import_graphql.Kind.INTERFACE_TYPE_DEFINITION,
+    name: nameNode(typeName),
+    fields: decodeFields(tuple[import_definition.InterfaceKeys.fields], types),
+    interfaces: (tuple[import_definition.InterfaceKeys.interfaces] || []).map((name) => ({
+      kind: import_graphql.Kind.NAMED_TYPE,
+      name: nameNode(name)
+    }))
+  };
+}
+function decodeUnionType(typeName, tuple) {
+  return {
+    kind: import_graphql.Kind.UNION_TYPE_DEFINITION,
+    name: nameNode(typeName),
+    types: tuple[import_definition.UnionKeys.types].map((name) => ({
+      kind: import_graphql.Kind.NAMED_TYPE,
+      name: nameNode(name)
+    }))
+  };
+}
+function decodeInputObjectType(typeName, tuple, types) {
+  return {
+    kind: import_graphql.Kind.INPUT_OBJECT_TYPE_DEFINITION,
+    name: nameNode(typeName),
+    fields: Object.entries(tuple[import_definition.InputObjectKeys.fields]).map(
+      ([name, value]) => decodeInputValue(name, value, types)
+    )
+  };
+}
+function decodeFields(fields, types) {
+  return Object.entries(fields).map(([name, value]) => {
+    var _a;
+    const type = Array.isArray(value) ? decodeTypeReference(value[import_definition.FieldKeys.type]) : decodeTypeReference(value);
+    return {
+      kind: import_graphql.Kind.FIELD_DEFINITION,
+      name: nameNode(name),
+      type,
+      arguments: decodeArguments(
+        Array.isArray(value) ? (_a = value[import_definition.FieldKeys.arguments]) != null ? _a : {} : {},
+        types
+      )
+    };
+  });
+}
+function decodeInputValue(name, value, types) {
+  const type = Array.isArray(value) ? decodeTypeReference(value[import_definition.InputValueKeys.type]) : decodeTypeReference(value);
+  return {
+    kind: import_graphql.Kind.INPUT_VALUE_DEFINITION,
+    name: nameNode(name),
+    type,
+    defaultValue: Array.isArray(value) ? valueToConstValueNode(
+      value[import_definition.InputValueKeys.defaultValue],
+      value[import_definition.InputValueKeys.type],
+      types
+    ) : void 0
+  };
+}
+function valueToConstValueNode(jsValue, typeRef, types) {
+  const typeName = (0, import_reference.typeNameFromReference)(typeRef);
+  if (typeof jsValue === "string") {
+    return typeName === "String" ? { kind: import_graphql.Kind.STRING, value: jsValue } : { kind: import_graphql.Kind.ENUM, value: jsValue };
+  }
+  if (jsValue === null) {
+    (0, import_invariant.invariant)(!(0, import_reference.isNonNullType)(typeRef), "Expecting nullable type");
+    return { kind: import_graphql.Kind.NULL };
+  }
+  if (Number.isInteger(jsValue)) {
+    return { kind: import_graphql.Kind.INT, value: String(jsValue) };
+  }
+  if (typeof jsValue === "number") {
+    return { kind: import_graphql.Kind.FLOAT, value: String(jsValue) };
+  }
+  if (Array.isArray(jsValue)) {
+    (0, import_invariant.invariant)((0, import_reference.isListType)(typeRef), "Expecting list type");
+    return {
+      kind: import_graphql.Kind.LIST,
+      values: jsValue.map(
+        (item) => valueToConstValueNode(item, (0, import_reference.unwrap)(typeRef), types)
+      )
+    };
+  }
+  if (typeof jsValue === "object") {
+    const typeDef = types[typeName];
+    (0, import_invariant.invariant)(
+      Array.isArray(typeDef) && typeDef[0] === import_definition.TypeKind.INPUT,
+      `Expecting input object type for ${typeName}, got ${typeDef == null ? void 0 : typeDef[0]}`
+    );
+    const fields = typeDef[import_definition.InputObjectKeys.fields];
+    return {
+      kind: import_graphql.Kind.OBJECT,
+      fields: Object.entries(jsValue).map(([name, value]) => {
+        const fieldDef = fields[name];
+        const fieldTypeRef = Array.isArray(fieldDef) ? fieldDef[import_definition.FieldKeys.type] : fieldDef;
+        (0, import_invariant.invariant)(
+          fieldTypeRef !== void 0,
+          `Could not find field definition for ${typeName}.${name}`
+        );
+        return {
+          kind: import_graphql.Kind.OBJECT_FIELD,
+          name: nameNode(name),
+          value: valueToConstValueNode(value, fieldTypeRef, types)
+        };
+      })
+    };
+  }
+  (0, import_invariant.invariant)(
+    false,
+    `Unexpected value for type ${(0, import_reference.inspectTypeReference)(typeRef)}: ${(0, import_inspect.inspect)(
+      jsValue
+    )}`
+  );
+}
+function decodeArguments(args, types) {
+  return Object.entries(args).map(
+    ([name, value]) => decodeInputValue(name, value, types)
+  );
+}
+function decodeTypeReference(ref) {
+  if ((0, import_reference.isListType)(ref)) {
+    return {
+      kind: import_graphql.Kind.LIST_TYPE,
+      type: decodeTypeReference((0, import_reference.unwrap)(ref))
+    };
+  }
+  if ((0, import_reference.isNonNullType)(ref)) {
+    const unwrappedType = decodeTypeReference((0, import_reference.unwrap)(ref));
+    (0, import_invariant.invariant)(
+      unwrappedType.kind !== import_graphql.Kind.NON_NULL_TYPE,
+      "Non-null modifier cannot be nested"
+    );
+    return {
+      kind: import_graphql.Kind.NON_NULL_TYPE,
+      type: unwrappedType
+    };
+  }
+  return {
+    kind: import_graphql.Kind.NAMED_TYPE,
+    name: nameNode((0, import_reference.typeNameFromReference)(ref))
+  };
+}
+function decodeDirective(tuple, types) {
+  const name = tuple[import_definition.DirectiveKeys.name];
+  const args = tuple[import_definition.DirectiveKeys.arguments] ? decodeArguments(tuple[import_definition.DirectiveKeys.arguments], types) : [];
+  return {
+    kind: import_graphql.Kind.DIRECTIVE_DEFINITION,
+    name: nameNode(name),
+    arguments: args,
+    // TODO? locations and repeatable are irrelevant for execution
+    repeatable: false,
+    locations: []
+  };
+}

package/lib/utilities/decodeASTSchema.js.map

@@ -0,0 +1,7 @@
+{
+  "version": 3,
+  "sources": ["../../src/utilities/decodeASTSchema.ts"],
+  "sourcesContent": ["import {\n  DirectiveDefinitionNode,\n  DocumentNode,\n  EnumTypeDefinitionNode,\n  FieldDefinitionNode,\n  InputObjectTypeDefinitionNode,\n  InputValueDefinitionNode,\n  InterfaceTypeDefinitionNode,\n  Kind,\n  ListTypeNode,\n  NamedTypeNode,\n  NameNode,\n  NonNullTypeNode,\n  ObjectTypeDefinitionNode,\n  ScalarTypeDefinitionNode,\n  UnionTypeDefinitionNode,\n} from \"graphql\";\n\nimport {\n  DirectiveDefinitionTuple,\n  DirectiveKeys,\n  SchemaFragmentDefinitions,\n  EnumKeys,\n  EnumTypeDefinitionTuple,\n  FieldDefinition,\n  FieldKeys,\n  InputObjectKeys,\n  InputObjectTypeDefinitionTuple,\n  InputValueDefinition,\n  InputValueKeys,\n  InterfaceKeys,\n  InterfaceTypeDefinitionTuple,\n  ObjectKeys,\n  ObjectTypeDefinitionTuple,\n  TypeDefinitionsRecord,\n  TypeKind,\n  TypeReference,\n  UnionKeys,\n  UnionTypeDefinitionTuple,\n} from \"../schema/definition\";\nimport {\n  inspectTypeReference,\n  isListType,\n  isNonNullType,\n  typeNameFromReference,\n  unwrap,\n} from \"../schema/reference\";\nimport { invariant } from \"../jsutils/invariant\";\nimport { ConstValueNode } from \"graphql/language/ast\";\nimport { inspect } from \"../jsutils/inspect\";\n\n/**\n * Converts encoded schema to standard AST representation of the same schema\n */\nexport function decodeSchema(\n  encodedSchema: SchemaFragmentDefinitions,\n): DocumentNode {\n  const definitions = [];\n  const types = encodedSchema.types;\n\n  for (const typeName in types) {\n    const tuple = types[typeName];\n    switch (tuple[0]) {\n      case TypeKind.SCALAR:\n        definitions.push(decodeScalarType(typeName));\n        break;\n      case TypeKind.ENUM:\n        definitions.push(decodeEnumType(typeName, tuple));\n        break;\n      case TypeKind.OBJECT:\n        definitions.push(decodeObjectType(typeName, tuple, types));\n        break;\n      case TypeKind.INTERFACE:\n        definitions.push(decodeInterfaceType(typeName, tuple, types));\n        break;\n      case TypeKind.UNION:\n        definitions.push(decodeUnionType(typeName, tuple));\n        break;\n      case TypeKind.INPUT:\n        definitions.push(decodeInputObjectType(typeName, tuple, types));\n        break;\n    }\n  }\n\n  for (const directive of encodedSchema.directives ?? []) {\n    definitions.push(decodeDirective(directive, types));\n  }\n\n  return { kind: Kind.DOCUMENT, definitions };\n}\n\nfunction nameNode(value: string): NameNode {\n  return { kind: Kind.NAME, value };\n}\n\nfunction decodeScalarType(typeName: string): ScalarTypeDefinitionNode {\n  return {\n    kind: Kind.SCALAR_TYPE_DEFINITION,\n    name: nameNode(typeName),\n  };\n}\n\nfunction decodeEnumType(\n  typeName: string,\n  tuple: EnumTypeDefinitionTuple,\n): EnumTypeDefinitionNode {\n  return {\n    kind: Kind.ENUM_TYPE_DEFINITION,\n    name: nameNode(typeName),\n    values: tuple[EnumKeys.values].map((value) => ({\n      kind: Kind.ENUM_VALUE_DEFINITION,\n      name: nameNode(value),\n    })),\n  };\n}\n\nfunction decodeObjectType(\n  typeName: string,\n  tuple: ObjectTypeDefinitionTuple,\n  types: TypeDefinitionsRecord,\n): ObjectTypeDefinitionNode {\n  return {\n    kind: Kind.OBJECT_TYPE_DEFINITION,\n    name: nameNode(typeName),\n    fields: decodeFields(tuple[ObjectKeys.fields], types),\n    interfaces: (tuple[ObjectKeys.interfaces] || []).map((name) => ({\n      kind: Kind.NAMED_TYPE,\n      name: nameNode(name),\n    })),\n  };\n}\n\nfunction decodeInterfaceType(\n  typeName: string,\n  tuple: InterfaceTypeDefinitionTuple,\n  types: TypeDefinitionsRecord,\n): InterfaceTypeDefinitionNode {\n  return {\n    kind: Kind.INTERFACE_TYPE_DEFINITION,\n    name: nameNode(typeName),\n    fields: decodeFields(tuple[InterfaceKeys.fields], types),\n    interfaces: (tuple[InterfaceKeys.interfaces] || []).map((name) => ({\n      kind: Kind.NAMED_TYPE,\n      name: nameNode(name),\n    })),\n  };\n}\n\nfunction decodeUnionType(\n  typeName: string,\n  tuple: UnionTypeDefinitionTuple,\n): UnionTypeDefinitionNode {\n  return {\n    kind: Kind.UNION_TYPE_DEFINITION,\n    name: nameNode(typeName),\n    types: tuple[UnionKeys.types].map((name) => ({\n      kind: Kind.NAMED_TYPE,\n      name: nameNode(name),\n    })),\n  };\n}\n\nfunction decodeInputObjectType(\n  typeName: string,\n  tuple: InputObjectTypeDefinitionTuple,\n  types: TypeDefinitionsRecord,\n): InputObjectTypeDefinitionNode {\n  return {\n    kind: Kind.INPUT_OBJECT_TYPE_DEFINITION,\n    name: nameNode(typeName),\n    fields: Object.entries(tuple[InputObjectKeys.fields]).map(([name, value]) =>\n      decodeInputValue(name, value, types),\n    ),\n  };\n}\n\nfunction decodeFields(\n  fields: Record<string, FieldDefinition>,\n  types: TypeDefinitionsRecord,\n): FieldDefinitionNode[] {\n  return Object.entries(fields).map(([name, value]) => {\n    const type = Array.isArray(value)\n      ? decodeTypeReference(value[FieldKeys.type])\n      : decodeTypeReference(value);\n    return {\n      kind: Kind.FIELD_DEFINITION,\n      name: nameNode(name),\n      type,\n      arguments: decodeArguments(\n        Array.isArray(value) ? value[FieldKeys.arguments] ?? {} : {},\n        types,\n      ),\n    };\n  });\n}\n\nfunction decodeInputValue(\n  name: string,\n  value: InputValueDefinition,\n  types: TypeDefinitionsRecord,\n): InputValueDefinitionNode {\n  const type = Array.isArray(value)\n    ? decodeTypeReference(value[InputValueKeys.type])\n    : decodeTypeReference(value);\n\n  return {\n    kind: Kind.INPUT_VALUE_DEFINITION,\n    name: nameNode(name),\n    type,\n    defaultValue: Array.isArray(value)\n      ? valueToConstValueNode(\n          value[InputValueKeys.defaultValue],\n          value[InputValueKeys.type],\n          types,\n        )\n      : undefined,\n  };\n}\n\nfunction valueToConstValueNode(\n  jsValue: unknown,\n  typeRef: TypeReference,\n  types: TypeDefinitionsRecord,\n): ConstValueNode {\n  const typeName = typeNameFromReference(typeRef);\n  if (typeof jsValue === \"string\") {\n    return typeName === \"String\"\n      ? { kind: Kind.STRING, value: jsValue }\n      : { kind: Kind.ENUM, value: jsValue };\n  }\n  if (jsValue === null) {\n    invariant(!isNonNullType(typeRef), \"Expecting nullable type\");\n    return { kind: Kind.NULL };\n  }\n  if (Number.isInteger(jsValue)) {\n    return { kind: Kind.INT, value: String(jsValue) };\n  }\n  if (typeof jsValue === \"number\") {\n    return { kind: Kind.FLOAT, value: String(jsValue) };\n  }\n  if (Array.isArray(jsValue)) {\n    invariant(isListType(typeRef), \"Expecting list type\");\n    return {\n      kind: Kind.LIST,\n      values: jsValue.map((item) =>\n        valueToConstValueNode(item, unwrap(typeRef), types),\n      ),\n    };\n  }\n  if (typeof jsValue === \"object\") {\n    const typeDef = types[typeName];\n    invariant(\n      Array.isArray(typeDef) && typeDef[0] === TypeKind.INPUT,\n      `Expecting input object type for ${typeName}, got ${typeDef?.[0]}`,\n    );\n    const fields = typeDef[InputObjectKeys.fields];\n    return {\n      kind: Kind.OBJECT,\n      fields: Object.entries(jsValue).map(([name, value]) => {\n        const fieldDef = fields[name];\n        const fieldTypeRef = Array.isArray(fieldDef)\n          ? fieldDef[FieldKeys.type]\n          : fieldDef;\n        invariant(\n          fieldTypeRef !== undefined,\n          `Could not find field definition for ${typeName}.${name}`,\n        );\n        return {\n          kind: Kind.OBJECT_FIELD,\n          name: nameNode(name),\n          value: valueToConstValueNode(value, fieldTypeRef, types),\n        };\n      }),\n    };\n  }\n  invariant(\n    false,\n    `Unexpected value for type ${inspectTypeReference(typeRef)}: ${inspect(\n      jsValue,\n    )}`,\n  );\n}\n\nfunction decodeArguments(\n  args: Record<string, InputValueDefinition>,\n  types: TypeDefinitionsRecord,\n): InputValueDefinitionNode[] {\n  return Object.entries(args).map(([name, value]) =>\n    decodeInputValue(name, value, types),\n  );\n}\n\nfunction decodeTypeReference(\n  ref: TypeReference,\n): NamedTypeNode | ListTypeNode | NonNullTypeNode {\n  if (isListType(ref)) {\n    return {\n      kind: Kind.LIST_TYPE,\n      type: decodeTypeReference(unwrap(ref)),\n    };\n  }\n  if (isNonNullType(ref)) {\n    const unwrappedType = decodeTypeReference(unwrap(ref));\n    invariant(\n      unwrappedType.kind !== Kind.NON_NULL_TYPE,\n      \"Non-null modifier cannot be nested\",\n    );\n    return {\n      kind: Kind.NON_NULL_TYPE,\n      type: unwrappedType,\n    };\n  }\n  return {\n    kind: Kind.NAMED_TYPE,\n    name: nameNode(typeNameFromReference(ref)),\n  };\n}\n\nfunction decodeDirective(\n  tuple: DirectiveDefinitionTuple,\n  types: TypeDefinitionsRecord,\n): DirectiveDefinitionNode {\n  const name = tuple[DirectiveKeys.name];\n  const args = tuple[DirectiveKeys.arguments]\n    ? decodeArguments(tuple[DirectiveKeys.arguments], types)\n    : [];\n  return {\n    kind: Kind.DIRECTIVE_DEFINITION,\n    name: nameNode(name),\n    arguments: args,\n    // TODO? locations and repeatable are irrelevant for execution\n    repeatable: false,\n    locations: [],\n  };\n}\n"],
+  "mappings": "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",
+  "names": []
+}