@galaxy-stack/orbit-graphql-federation 0.1.5 → 0.1.7

package/dist/index.js

@@ -106,3143 +106,535 @@ function ReferenceResolver() {
 }
 // src/schema/federation-schema-builder.ts
 import"reflect-metadata";
-// ../../node_modules/graphql/jsutils/devAssert.mjs
-function devAssert(condition, message) {
-  const booleanCondition = Boolean(condition);
-  if (!booleanCondition) {
-    throw new Error(message);
-  }
-}
-
-// ../../node_modules/graphql/jsutils/inspect.mjs
-var MAX_ARRAY_LENGTH = 10;
-var MAX_RECURSIVE_DEPTH = 2;
-function inspect(value) {
-  return formatValue(value, []);
-}
-function formatValue(value, seenValues) {
-  switch (typeof value) {
-    case "string":
-      return JSON.stringify(value);
-    case "function":
-      return value.name ? `[function ${value.name}]` : "[function]";
-    case "object":
-      return formatObjectValue(value, seenValues);
-    default:
-      return String(value);
-  }
-}
-function formatObjectValue(value, previouslySeenValues) {
-  if (value === null) {
-    return "null";
-  }
-  if (previouslySeenValues.includes(value)) {
-    return "[Circular]";
-  }
-  const seenValues = [...previouslySeenValues, value];
-  if (isJSONable(value)) {
-    const jsonValue = value.toJSON();
-    if (jsonValue !== value) {
-      return typeof jsonValue === "string" ? jsonValue : formatValue(jsonValue, seenValues);
-    }
-  } else if (Array.isArray(value)) {
-    return formatArray(value, seenValues);
-  }
-  return formatObject(value, seenValues);
-}
-function isJSONable(value) {
-  return typeof value.toJSON === "function";
-}
-function formatObject(object, seenValues) {
-  const entries = Object.entries(object);
-  if (entries.length === 0) {
-    return "{}";
-  }
-  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-    return "[" + getObjectTag(object) + "]";
-  }
-  const properties = entries.map(([key, value]) => key + ": " + formatValue(value, seenValues));
-  return "{ " + properties.join(", ") + " }";
-}
-function formatArray(array, seenValues) {
-  if (array.length === 0) {
-    return "[]";
-  }
-  if (seenValues.length > MAX_RECURSIVE_DEPTH) {
-    return "[Array]";
-  }
-  const len = Math.min(MAX_ARRAY_LENGTH, array.length);
-  const remaining = array.length - len;
-  const items = [];
-  for (let i = 0;i < len; ++i) {
-    items.push(formatValue(array[i], seenValues));
-  }
-  if (remaining === 1) {
-    items.push("... 1 more item");
-  } else if (remaining > 1) {
-    items.push(`... ${remaining} more items`);
-  }
-  return "[" + items.join(", ") + "]";
-}
-function getObjectTag(object) {
-  const tag = Object.prototype.toString.call(object).replace(/^\[object /, "").replace(/]$/, "");
-  if (tag === "Object" && typeof object.constructor === "function") {
-    const name = object.constructor.name;
-    if (typeof name === "string" && name !== "") {
-      return name;
-    }
-  }
-  return tag;
-}
-
-// ../../node_modules/graphql/jsutils/instanceOf.mjs
-var isProduction = globalThis.process && false;
-var instanceOf = isProduction ? function instanceOf(value, constructor) {
-  return value instanceof constructor;
-} : function instanceOf(value, constructor) {
-  if (value instanceof constructor) {
-    return true;
-  }
-  if (typeof value === "object" && value !== null) {
-    var _value$constructor;
-    const className = constructor.prototype[Symbol.toStringTag];
-    const valueClassName = Symbol.toStringTag in value ? value[Symbol.toStringTag] : (_value$constructor = value.constructor) === null || _value$constructor === undefined ? undefined : _value$constructor.name;
-    if (className === valueClassName) {
-      const stringifiedValue = inspect(value);
-      throw new Error(`Cannot use ${className} "${stringifiedValue}" from another module or realm.
-
-Ensure that there is only one instance of "graphql" in the node_modules
-directory. If different versions of "graphql" are the dependencies of other
-relied on modules, use "resolutions" to ensure only one version is installed.
-
-https://yarnpkg.com/en/docs/selective-version-resolutions
-
-Duplicate "graphql" modules cannot be used at the same time since different
-versions may have different capabilities and behavior. The data from one
-version used in the function from another could produce confusing and
-spurious results.`);
-    }
-  }
-  return false;
-};
-
-// ../../node_modules/graphql/jsutils/isObjectLike.mjs
-function isObjectLike(value) {
-  return typeof value == "object" && value !== null;
-}
-
-// ../../node_modules/graphql/jsutils/toObjMap.mjs
-function toObjMap(obj) {
-  if (obj == null) {
-    return Object.create(null);
-  }
-  if (Object.getPrototypeOf(obj) === null) {
-    return obj;
-  }
-  const map = Object.create(null);
-  for (const [key, value] of Object.entries(obj)) {
-    map[key] = value;
-  }
-  return map;
-}
-
-// ../../node_modules/graphql/language/ast.mjs
-var QueryDocumentKeys = {
-  Name: [],
-  Document: ["definitions"],
-  OperationDefinition: [
-    "description",
-    "name",
-    "variableDefinitions",
-    "directives",
-    "selectionSet"
-  ],
-  VariableDefinition: [
-    "description",
-    "variable",
-    "type",
-    "defaultValue",
-    "directives"
-  ],
-  Variable: ["name"],
-  SelectionSet: ["selections"],
-  Field: ["alias", "name", "arguments", "directives", "selectionSet"],
-  Argument: ["name", "value"],
-  FragmentSpread: ["name", "directives"],
-  InlineFragment: ["typeCondition", "directives", "selectionSet"],
-  FragmentDefinition: [
-    "description",
-    "name",
-    "variableDefinitions",
-    "typeCondition",
-    "directives",
-    "selectionSet"
-  ],
-  IntValue: [],
-  FloatValue: [],
-  StringValue: [],
-  BooleanValue: [],
-  NullValue: [],
-  EnumValue: [],
-  ListValue: ["values"],
-  ObjectValue: ["fields"],
-  ObjectField: ["name", "value"],
-  Directive: ["name", "arguments"],
-  NamedType: ["name"],
-  ListType: ["type"],
-  NonNullType: ["type"],
-  SchemaDefinition: ["description", "directives", "operationTypes"],
-  OperationTypeDefinition: ["type"],
-  ScalarTypeDefinition: ["description", "name", "directives"],
-  ObjectTypeDefinition: [
-    "description",
-    "name",
-    "interfaces",
-    "directives",
-    "fields"
-  ],
-  FieldDefinition: ["description", "name", "arguments", "type", "directives"],
-  InputValueDefinition: [
-    "description",
-    "name",
-    "type",
-    "defaultValue",
-    "directives"
-  ],
-  InterfaceTypeDefinition: [
-    "description",
-    "name",
-    "interfaces",
-    "directives",
-    "fields"
-  ],
-  UnionTypeDefinition: ["description", "name", "directives", "types"],
-  EnumTypeDefinition: ["description", "name", "directives", "values"],
-  EnumValueDefinition: ["description", "name", "directives"],
-  InputObjectTypeDefinition: ["description", "name", "directives", "fields"],
-  DirectiveDefinition: ["description", "name", "arguments", "locations"],
-  SchemaExtension: ["directives", "operationTypes"],
-  ScalarTypeExtension: ["name", "directives"],
-  ObjectTypeExtension: ["name", "interfaces", "directives", "fields"],
-  InterfaceTypeExtension: ["name", "interfaces", "directives", "fields"],
-  UnionTypeExtension: ["name", "directives", "types"],
-  EnumTypeExtension: ["name", "directives", "values"],
-  InputObjectTypeExtension: ["name", "directives", "fields"],
-  TypeCoordinate: ["name"],
-  MemberCoordinate: ["name", "memberName"],
-  ArgumentCoordinate: ["name", "fieldName", "argumentName"],
-  DirectiveCoordinate: ["name"],
-  DirectiveArgumentCoordinate: ["name", "argumentName"]
-};
-var kindValues = new Set(Object.keys(QueryDocumentKeys));
-function isNode(maybeNode) {
-  const maybeKind = maybeNode === null || maybeNode === undefined ? undefined : maybeNode.kind;
-  return typeof maybeKind === "string" && kindValues.has(maybeKind);
-}
-var OperationTypeNode;
-(function(OperationTypeNode) {
-  OperationTypeNode["QUERY"] = "query";
-  OperationTypeNode["MUTATION"] = "mutation";
-  OperationTypeNode["SUBSCRIPTION"] = "subscription";
-})(OperationTypeNode || (OperationTypeNode = {}));
-
-// ../../node_modules/graphql/jsutils/didYouMean.mjs
-var MAX_SUGGESTIONS = 5;
-function didYouMean(firstArg, secondArg) {
-  const [subMessage, suggestionsArg] = secondArg ? [firstArg, secondArg] : [undefined, firstArg];
-  let message = " Did you mean ";
-  if (subMessage) {
-    message += subMessage + " ";
-  }
-  const suggestions = suggestionsArg.map((x) => `"${x}"`);
-  switch (suggestions.length) {
-    case 0:
-      return "";
-    case 1:
-      return message + suggestions[0] + "?";
-    case 2:
-      return message + suggestions[0] + " or " + suggestions[1] + "?";
-  }
-  const selected = suggestions.slice(0, MAX_SUGGESTIONS);
-  const lastItem = selected.pop();
-  return message + selected.join(", ") + ", or " + lastItem + "?";
-}
-
-// ../../node_modules/graphql/jsutils/identityFunc.mjs
-function identityFunc(x) {
-  return x;
-}
-
-// ../../node_modules/graphql/jsutils/keyMap.mjs
-function keyMap(list, keyFn) {
-  const result = Object.create(null);
-  for (const item of list) {
-    result[keyFn(item)] = item;
-  }
-  return result;
-}
-
-// ../../node_modules/graphql/jsutils/keyValMap.mjs
-function keyValMap(list, keyFn, valFn) {
-  const result = Object.create(null);
-  for (const item of list) {
-    result[keyFn(item)] = valFn(item);
-  }
-  return result;
-}
-
-// ../../node_modules/graphql/jsutils/mapValue.mjs
-function mapValue(map, fn) {
-  const result = Object.create(null);
-  for (const key of Object.keys(map)) {
-    result[key] = fn(map[key], key);
-  }
-  return result;
-}
-
-// ../../node_modules/graphql/jsutils/naturalCompare.mjs
-function naturalCompare(aStr, bStr) {
-  let aIndex = 0;
-  let bIndex = 0;
-  while (aIndex < aStr.length && bIndex < bStr.length) {
-    let aChar = aStr.charCodeAt(aIndex);
-    let bChar = bStr.charCodeAt(bIndex);
-    if (isDigit(aChar) && isDigit(bChar)) {
-      let aNum = 0;
-      do {
-        ++aIndex;
-        aNum = aNum * 10 + aChar - DIGIT_0;
-        aChar = aStr.charCodeAt(aIndex);
-      } while (isDigit(aChar) && aNum > 0);
-      let bNum = 0;
-      do {
-        ++bIndex;
-        bNum = bNum * 10 + bChar - DIGIT_0;
-        bChar = bStr.charCodeAt(bIndex);
-      } while (isDigit(bChar) && bNum > 0);
-      if (aNum < bNum) {
-        return -1;
-      }
-      if (aNum > bNum) {
-        return 1;
-      }
-    } else {
-      if (aChar < bChar) {
-        return -1;
-      }
-      if (aChar > bChar) {
-        return 1;
-      }
-      ++aIndex;
-      ++bIndex;
-    }
-  }
-  return aStr.length - bStr.length;
-}
-var DIGIT_0 = 48;
-var DIGIT_9 = 57;
-function isDigit(code) {
-  return !isNaN(code) && DIGIT_0 <= code && code <= DIGIT_9;
-}
-
-// ../../node_modules/graphql/jsutils/suggestionList.mjs
-function suggestionList(input, options) {
-  const optionsByDistance = Object.create(null);
-  const lexicalDistance = new LexicalDistance(input);
-  const threshold = Math.floor(input.length * 0.4) + 1;
-  for (const option of options) {
-    const distance = lexicalDistance.measure(option, threshold);
-    if (distance !== undefined) {
-      optionsByDistance[option] = distance;
-    }
-  }
-  return Object.keys(optionsByDistance).sort((a, b) => {
-    const distanceDiff = optionsByDistance[a] - optionsByDistance[b];
-    return distanceDiff !== 0 ? distanceDiff : naturalCompare(a, b);
-  });
-}
-
-class LexicalDistance {
-  constructor(input) {
-    this._input = input;
-    this._inputLowerCase = input.toLowerCase();
-    this._inputArray = stringToArray(this._inputLowerCase);
-    this._rows = [
-      new Array(input.length + 1).fill(0),
-      new Array(input.length + 1).fill(0),
-      new Array(input.length + 1).fill(0)
-    ];
-  }
-  measure(option, threshold) {
-    if (this._input === option) {
-      return 0;
-    }
-    const optionLowerCase = option.toLowerCase();
-    if (this._inputLowerCase === optionLowerCase) {
-      return 1;
-    }
-    let a = stringToArray(optionLowerCase);
-    let b = this._inputArray;
-    if (a.length < b.length) {
-      const tmp = a;
-      a = b;
-      b = tmp;
-    }
-    const aLength = a.length;
-    const bLength = b.length;
-    if (aLength - bLength > threshold) {
-      return;
-    }
-    const rows = this._rows;
-    for (let j = 0;j <= bLength; j++) {
-      rows[0][j] = j;
-    }
-    for (let i = 1;i <= aLength; i++) {
-      const upRow = rows[(i - 1) % 3];
-      const currentRow = rows[i % 3];
-      let smallestCell = currentRow[0] = i;
-      for (let j = 1;j <= bLength; j++) {
-        const cost = a[i - 1] === b[j - 1] ? 0 : 1;
-        let currentCell = Math.min(upRow[j] + 1, currentRow[j - 1] + 1, upRow[j - 1] + cost);
-        if (i > 1 && j > 1 && a[i - 1] === b[j - 2] && a[i - 2] === b[j - 1]) {
-          const doubleDiagonalCell = rows[(i - 2) % 3][j - 2];
-          currentCell = Math.min(currentCell, doubleDiagonalCell + 1);
-        }
-        if (currentCell < smallestCell) {
-          smallestCell = currentCell;
-        }
-        currentRow[j] = currentCell;
-      }
-      if (smallestCell > threshold) {
-        return;
-      }
-    }
-    const distance = rows[aLength % 3][bLength];
-    return distance <= threshold ? distance : undefined;
-  }
-}
-function stringToArray(str) {
-  const strLength = str.length;
-  const array = new Array(strLength);
-  for (let i = 0;i < strLength; ++i) {
-    array[i] = str.charCodeAt(i);
-  }
-  return array;
-}
-
-// ../../node_modules/graphql/jsutils/invariant.mjs
-function invariant(condition, message) {
-  const booleanCondition = Boolean(condition);
-  if (!booleanCondition) {
-    throw new Error(message != null ? message : "Unexpected invariant triggered.");
-  }
-}
-
-// ../../node_modules/graphql/language/location.mjs
-var LineRegExp = /\r\n|[\n\r]/g;
-function getLocation(source, position) {
-  let lastLineStart = 0;
-  let line = 1;
-  for (const match of source.body.matchAll(LineRegExp)) {
-    typeof match.index === "number" || invariant(false);
-    if (match.index >= position) {
-      break;
-    }
-    lastLineStart = match.index + match[0].length;
-    line += 1;
-  }
-  return {
-    line,
-    column: position + 1 - lastLineStart
-  };
-}
-
-// ../../node_modules/graphql/language/printLocation.mjs
-function printLocation(location) {
-  return printSourceLocation(location.source, getLocation(location.source, location.start));
-}
-function printSourceLocation(source, sourceLocation) {
-  const firstLineColumnOffset = source.locationOffset.column - 1;
-  const body = "".padStart(firstLineColumnOffset) + source.body;
-  const lineIndex = sourceLocation.line - 1;
-  const lineOffset = source.locationOffset.line - 1;
-  const lineNum = sourceLocation.line + lineOffset;
-  const columnOffset = sourceLocation.line === 1 ? firstLineColumnOffset : 0;
-  const columnNum = sourceLocation.column + columnOffset;
-  const locationStr = `${source.name}:${lineNum}:${columnNum}
-`;
-  const lines = body.split(/\r\n|[\n\r]/g);
-  const locationLine = lines[lineIndex];
-  if (locationLine.length > 120) {
-    const subLineIndex = Math.floor(columnNum / 80);
-    const subLineColumnNum = columnNum % 80;
-    const subLines = [];
-    for (let i = 0;i < locationLine.length; i += 80) {
-      subLines.push(locationLine.slice(i, i + 80));
-    }
-    return locationStr + printPrefixedLines([
-      [`${lineNum} |`, subLines[0]],
-      ...subLines.slice(1, subLineIndex + 1).map((subLine) => ["|", subLine]),
-      ["|", "^".padStart(subLineColumnNum)],
-      ["|", subLines[subLineIndex + 1]]
-    ]);
-  }
-  return locationStr + printPrefixedLines([
-    [`${lineNum - 1} |`, lines[lineIndex - 1]],
-    [`${lineNum} |`, locationLine],
-    ["|", "^".padStart(columnNum)],
-    [`${lineNum + 1} |`, lines[lineIndex + 1]]
-  ]);
-}
-function printPrefixedLines(lines) {
-  const existingLines = lines.filter(([_, line]) => line !== undefined);
-  const padLen = Math.max(...existingLines.map(([prefix]) => prefix.length));
-  return existingLines.map(([prefix, line]) => prefix.padStart(padLen) + (line ? " " + line : "")).join(`
-`);
-}
-
-// ../../node_modules/graphql/error/GraphQLError.mjs
-function toNormalizedOptions(args) {
-  const firstArg = args[0];
-  if (firstArg == null || "kind" in firstArg || "length" in firstArg) {
-    return {
-      nodes: firstArg,
-      source: args[1],
-      positions: args[2],
-      path: args[3],
-      originalError: args[4],
-      extensions: args[5]
-    };
-  }
-  return firstArg;
-}
-
-class GraphQLError extends Error {
-  constructor(message, ...rawArgs) {
-    var _this$nodes, _nodeLocations$, _ref;
-    const { nodes, source, positions, path, originalError, extensions } = toNormalizedOptions(rawArgs);
-    super(message);
-    this.name = "GraphQLError";
-    this.path = path !== null && path !== undefined ? path : undefined;
-    this.originalError = originalError !== null && originalError !== undefined ? originalError : undefined;
-    this.nodes = undefinedIfEmpty(Array.isArray(nodes) ? nodes : nodes ? [nodes] : undefined);
-    const nodeLocations = undefinedIfEmpty((_this$nodes = this.nodes) === null || _this$nodes === undefined ? undefined : _this$nodes.map((node) => node.loc).filter((loc) => loc != null));
-    this.source = source !== null && source !== undefined ? source : nodeLocations === null || nodeLocations === undefined ? undefined : (_nodeLocations$ = nodeLocations[0]) === null || _nodeLocations$ === undefined ? undefined : _nodeLocations$.source;
-    this.positions = positions !== null && positions !== undefined ? positions : nodeLocations === null || nodeLocations === undefined ? undefined : nodeLocations.map((loc) => loc.start);
-    this.locations = positions && source ? positions.map((pos) => getLocation(source, pos)) : nodeLocations === null || nodeLocations === undefined ? undefined : nodeLocations.map((loc) => getLocation(loc.source, loc.start));
-    const originalExtensions = isObjectLike(originalError === null || originalError === undefined ? undefined : originalError.extensions) ? originalError === null || originalError === undefined ? undefined : originalError.extensions : undefined;
-    this.extensions = (_ref = extensions !== null && extensions !== undefined ? extensions : originalExtensions) !== null && _ref !== undefined ? _ref : Object.create(null);
-    Object.defineProperties(this, {
-      message: {
-        writable: true,
-        enumerable: true
-      },
-      name: {
-        enumerable: false
-      },
-      nodes: {
-        enumerable: false
-      },
-      source: {
-        enumerable: false
-      },
-      positions: {
-        enumerable: false
-      },
-      originalError: {
-        enumerable: false
-      }
-    });
-    if (originalError !== null && originalError !== undefined && originalError.stack) {
-      Object.defineProperty(this, "stack", {
-        value: originalError.stack,
-        writable: true,
-        configurable: true
-      });
-    } else if (Error.captureStackTrace) {
-      Error.captureStackTrace(this, GraphQLError);
-    } else {
-      Object.defineProperty(this, "stack", {
-        value: Error().stack,
-        writable: true,
-        configurable: true
-      });
-    }
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLError";
-  }
-  toString() {
-    let output = this.message;
-    if (this.nodes) {
-      for (const node of this.nodes) {
-        if (node.loc) {
-          output += `
-
-` + printLocation(node.loc);
-        }
-      }
-    } else if (this.source && this.locations) {
-      for (const location of this.locations) {
-        output += `
-
-` + printSourceLocation(this.source, location);
-      }
-    }
-    return output;
-  }
-  toJSON() {
-    const formattedError = {
-      message: this.message
-    };
-    if (this.locations != null) {
-      formattedError.locations = this.locations;
-    }
-    if (this.path != null) {
-      formattedError.path = this.path;
-    }
-    if (this.extensions != null && Object.keys(this.extensions).length > 0) {
-      formattedError.extensions = this.extensions;
-    }
-    return formattedError;
-  }
-}
-function undefinedIfEmpty(array) {
-  return array === undefined || array.length === 0 ? undefined : array;
-}
-
-// ../../node_modules/graphql/language/kinds.mjs
-var Kind;
-(function(Kind) {
-  Kind["NAME"] = "Name";
-  Kind["DOCUMENT"] = "Document";
-  Kind["OPERATION_DEFINITION"] = "OperationDefinition";
-  Kind["VARIABLE_DEFINITION"] = "VariableDefinition";
-  Kind["SELECTION_SET"] = "SelectionSet";
-  Kind["FIELD"] = "Field";
-  Kind["ARGUMENT"] = "Argument";
-  Kind["FRAGMENT_SPREAD"] = "FragmentSpread";
-  Kind["INLINE_FRAGMENT"] = "InlineFragment";
-  Kind["FRAGMENT_DEFINITION"] = "FragmentDefinition";
-  Kind["VARIABLE"] = "Variable";
-  Kind["INT"] = "IntValue";
-  Kind["FLOAT"] = "FloatValue";
-  Kind["STRING"] = "StringValue";
-  Kind["BOOLEAN"] = "BooleanValue";
-  Kind["NULL"] = "NullValue";
-  Kind["ENUM"] = "EnumValue";
-  Kind["LIST"] = "ListValue";
-  Kind["OBJECT"] = "ObjectValue";
-  Kind["OBJECT_FIELD"] = "ObjectField";
-  Kind["DIRECTIVE"] = "Directive";
-  Kind["NAMED_TYPE"] = "NamedType";
-  Kind["LIST_TYPE"] = "ListType";
-  Kind["NON_NULL_TYPE"] = "NonNullType";
-  Kind["SCHEMA_DEFINITION"] = "SchemaDefinition";
-  Kind["OPERATION_TYPE_DEFINITION"] = "OperationTypeDefinition";
-  Kind["SCALAR_TYPE_DEFINITION"] = "ScalarTypeDefinition";
-  Kind["OBJECT_TYPE_DEFINITION"] = "ObjectTypeDefinition";
-  Kind["FIELD_DEFINITION"] = "FieldDefinition";
-  Kind["INPUT_VALUE_DEFINITION"] = "InputValueDefinition";
-  Kind["INTERFACE_TYPE_DEFINITION"] = "InterfaceTypeDefinition";
-  Kind["UNION_TYPE_DEFINITION"] = "UnionTypeDefinition";
-  Kind["ENUM_TYPE_DEFINITION"] = "EnumTypeDefinition";
-  Kind["ENUM_VALUE_DEFINITION"] = "EnumValueDefinition";
-  Kind["INPUT_OBJECT_TYPE_DEFINITION"] = "InputObjectTypeDefinition";
-  Kind["DIRECTIVE_DEFINITION"] = "DirectiveDefinition";
-  Kind["SCHEMA_EXTENSION"] = "SchemaExtension";
-  Kind["SCALAR_TYPE_EXTENSION"] = "ScalarTypeExtension";
-  Kind["OBJECT_TYPE_EXTENSION"] = "ObjectTypeExtension";
-  Kind["INTERFACE_TYPE_EXTENSION"] = "InterfaceTypeExtension";
-  Kind["UNION_TYPE_EXTENSION"] = "UnionTypeExtension";
-  Kind["ENUM_TYPE_EXTENSION"] = "EnumTypeExtension";
-  Kind["INPUT_OBJECT_TYPE_EXTENSION"] = "InputObjectTypeExtension";
-  Kind["TYPE_COORDINATE"] = "TypeCoordinate";
-  Kind["MEMBER_COORDINATE"] = "MemberCoordinate";
-  Kind["ARGUMENT_COORDINATE"] = "ArgumentCoordinate";
-  Kind["DIRECTIVE_COORDINATE"] = "DirectiveCoordinate";
-  Kind["DIRECTIVE_ARGUMENT_COORDINATE"] = "DirectiveArgumentCoordinate";
-})(Kind || (Kind = {}));
-
-// ../../node_modules/graphql/language/characterClasses.mjs
-function isWhiteSpace(code) {
-  return code === 9 || code === 32;
-}
-function isDigit2(code) {
-  return code >= 48 && code <= 57;
-}
-function isLetter(code) {
-  return code >= 97 && code <= 122 || code >= 65 && code <= 90;
-}
-function isNameStart(code) {
-  return isLetter(code) || code === 95;
-}
-function isNameContinue(code) {
-  return isLetter(code) || isDigit2(code) || code === 95;
-}
-
-// ../../node_modules/graphql/language/blockString.mjs
-function isPrintableAsBlockString(value) {
-  if (value === "") {
-    return true;
-  }
-  let isEmptyLine = true;
-  let hasIndent = false;
-  let hasCommonIndent = true;
-  let seenNonEmptyLine = false;
-  for (let i = 0;i < value.length; ++i) {
-    switch (value.codePointAt(i)) {
-      case 0:
-      case 1:
-      case 2:
-      case 3:
-      case 4:
-      case 5:
-      case 6:
-      case 7:
-      case 8:
-      case 11:
-      case 12:
-      case 14:
-      case 15:
-        return false;
-      case 13:
-        return false;
-      case 10:
-        if (isEmptyLine && !seenNonEmptyLine) {
-          return false;
-        }
-        seenNonEmptyLine = true;
-        isEmptyLine = true;
-        hasIndent = false;
-        break;
-      case 9:
-      case 32:
-        hasIndent || (hasIndent = isEmptyLine);
-        break;
-      default:
-        hasCommonIndent && (hasCommonIndent = hasIndent);
-        isEmptyLine = false;
-    }
-  }
-  if (isEmptyLine) {
-    return false;
-  }
-  if (hasCommonIndent && seenNonEmptyLine) {
-    return false;
-  }
-  return true;
-}
-function printBlockString(value, options) {
-  const escapedValue = value.replace(/"""/g, '\\"""');
-  const lines = escapedValue.split(/\r\n|[\n\r]/g);
-  const isSingleLine = lines.length === 1;
-  const forceLeadingNewLine = lines.length > 1 && lines.slice(1).every((line) => line.length === 0 || isWhiteSpace(line.charCodeAt(0)));
-  const hasTrailingTripleQuotes = escapedValue.endsWith('\\"""');
-  const hasTrailingQuote = value.endsWith('"') && !hasTrailingTripleQuotes;
-  const hasTrailingSlash = value.endsWith("\\");
-  const forceTrailingNewline = hasTrailingQuote || hasTrailingSlash;
-  const printAsMultipleLines = !(options !== null && options !== undefined && options.minimize) && (!isSingleLine || value.length > 70 || forceTrailingNewline || forceLeadingNewLine || hasTrailingTripleQuotes);
-  let result = "";
-  const skipLeadingNewLine = isSingleLine && isWhiteSpace(value.charCodeAt(0));
-  if (printAsMultipleLines && !skipLeadingNewLine || forceLeadingNewLine) {
-    result += `
-`;
-  }
-  result += escapedValue;
-  if (printAsMultipleLines || forceTrailingNewline) {
-    result += `
-`;
-  }
-  return '"""' + result + '"""';
-}
-
-// ../../node_modules/graphql/language/printString.mjs
-function printString(str) {
-  return `"${str.replace(escapedRegExp, escapedReplacer)}"`;
-}
-var escapedRegExp = /[\x00-\x1f\x22\x5c\x7f-\x9f]/g;
-function escapedReplacer(str) {
-  return escapeSequences[str.charCodeAt(0)];
-}
-var escapeSequences = [
-  "\\u0000",
-  "\\u0001",
-  "\\u0002",
-  "\\u0003",
-  "\\u0004",
-  "\\u0005",
-  "\\u0006",
-  "\\u0007",
-  "\\b",
-  "\\t",
-  "\\n",
-  "\\u000B",
-  "\\f",
-  "\\r",
-  "\\u000E",
-  "\\u000F",
-  "\\u0010",
-  "\\u0011",
-  "\\u0012",
-  "\\u0013",
-  "\\u0014",
-  "\\u0015",
-  "\\u0016",
-  "\\u0017",
-  "\\u0018",
-  "\\u0019",
-  "\\u001A",
-  "\\u001B",
-  "\\u001C",
-  "\\u001D",
-  "\\u001E",
-  "\\u001F",
-  "",
-  "",
-  "\\\"",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "\\\\",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "",
-  "\\u007F",
-  "\\u0080",
-  "\\u0081",
-  "\\u0082",
-  "\\u0083",
-  "\\u0084",
-  "\\u0085",
-  "\\u0086",
-  "\\u0087",
-  "\\u0088",
-  "\\u0089",
-  "\\u008A",
-  "\\u008B",
-  "\\u008C",
-  "\\u008D",
-  "\\u008E",
-  "\\u008F",
-  "\\u0090",
-  "\\u0091",
-  "\\u0092",
-  "\\u0093",
-  "\\u0094",
-  "\\u0095",
-  "\\u0096",
-  "\\u0097",
-  "\\u0098",
-  "\\u0099",
-  "\\u009A",
-  "\\u009B",
-  "\\u009C",
-  "\\u009D",
-  "\\u009E",
-  "\\u009F"
-];
-
-// ../../node_modules/graphql/language/visitor.mjs
-var BREAK = Object.freeze({});
-function visit(root, visitor, visitorKeys = QueryDocumentKeys) {
-  const enterLeaveMap = new Map;
-  for (const kind of Object.values(Kind)) {
-    enterLeaveMap.set(kind, getEnterLeaveForKind(visitor, kind));
-  }
-  let stack = undefined;
-  let inArray = Array.isArray(root);
-  let keys = [root];
-  let index = -1;
-  let edits = [];
-  let node = root;
-  let key = undefined;
-  let parent = undefined;
-  const path = [];
-  const ancestors = [];
-  do {
-    index++;
-    const isLeaving = index === keys.length;
-    const isEdited = isLeaving && edits.length !== 0;
-    if (isLeaving) {
-      key = ancestors.length === 0 ? undefined : path[path.length - 1];
-      node = parent;
-      parent = ancestors.pop();
-      if (isEdited) {
-        if (inArray) {
-          node = node.slice();
-          let editOffset = 0;
-          for (const [editKey, editValue] of edits) {
-            const arrayKey = editKey - editOffset;
-            if (editValue === null) {
-              node.splice(arrayKey, 1);
-              editOffset++;
-            } else {
-              node[arrayKey] = editValue;
-            }
-          }
-        } else {
-          node = { ...node };
-          for (const [editKey, editValue] of edits) {
-            node[editKey] = editValue;
-          }
-        }
-      }
-      index = stack.index;
-      keys = stack.keys;
-      edits = stack.edits;
-      inArray = stack.inArray;
-      stack = stack.prev;
-    } else if (parent) {
-      key = inArray ? index : keys[index];
-      node = parent[key];
-      if (node === null || node === undefined) {
-        continue;
-      }
-      path.push(key);
-    }
-    let result;
-    if (!Array.isArray(node)) {
-      var _enterLeaveMap$get, _enterLeaveMap$get2;
-      isNode(node) || devAssert(false, `Invalid AST Node: ${inspect(node)}.`);
-      const visitFn = isLeaving ? (_enterLeaveMap$get = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get === undefined ? undefined : _enterLeaveMap$get.leave : (_enterLeaveMap$get2 = enterLeaveMap.get(node.kind)) === null || _enterLeaveMap$get2 === undefined ? undefined : _enterLeaveMap$get2.enter;
-      result = visitFn === null || visitFn === undefined ? undefined : visitFn.call(visitor, node, key, parent, path, ancestors);
-      if (result === BREAK) {
-        break;
-      }
-      if (result === false) {
-        if (!isLeaving) {
-          path.pop();
-          continue;
-        }
-      } else if (result !== undefined) {
-        edits.push([key, result]);
-        if (!isLeaving) {
-          if (isNode(result)) {
-            node = result;
-          } else {
-            path.pop();
-            continue;
-          }
-        }
-      }
-    }
-    if (result === undefined && isEdited) {
-      edits.push([key, node]);
-    }
-    if (isLeaving) {
-      path.pop();
-    } else {
-      var _node$kind;
-      stack = {
-        inArray,
-        index,
-        keys,
-        edits,
-        prev: stack
-      };
-      inArray = Array.isArray(node);
-      keys = inArray ? node : (_node$kind = visitorKeys[node.kind]) !== null && _node$kind !== undefined ? _node$kind : [];
-      index = -1;
-      edits = [];
-      if (parent) {
-        ancestors.push(parent);
-      }
-      parent = node;
-    }
-  } while (stack !== undefined);
-  if (edits.length !== 0) {
-    return edits[edits.length - 1][1];
-  }
-  return root;
-}
-function getEnterLeaveForKind(visitor, kind) {
-  const kindVisitor = visitor[kind];
-  if (typeof kindVisitor === "object") {
-    return kindVisitor;
-  } else if (typeof kindVisitor === "function") {
-    return {
-      enter: kindVisitor,
-      leave: undefined
-    };
-  }
-  return {
-    enter: visitor.enter,
-    leave: visitor.leave
-  };
-}
-
-// ../../node_modules/graphql/language/printer.mjs
-function print(ast) {
-  return visit(ast, printDocASTReducer);
-}
-var MAX_LINE_LENGTH = 80;
-var printDocASTReducer = {
-  Name: {
-    leave: (node) => node.value
-  },
-  Variable: {
-    leave: (node) => "$" + node.name
-  },
-  Document: {
-    leave: (node) => join(node.definitions, `
-
-`)
-  },
-  OperationDefinition: {
-    leave(node) {
-      const varDefs = hasMultilineItems(node.variableDefinitions) ? wrap(`(
-`, join(node.variableDefinitions, `
-`), `
-)`) : wrap("(", join(node.variableDefinitions, ", "), ")");
-      const prefix = wrap("", node.description, `
-`) + join([
-        node.operation,
-        join([node.name, varDefs]),
-        join(node.directives, " ")
-      ], " ");
-      return (prefix === "query" ? "" : prefix + " ") + node.selectionSet;
-    }
-  },
-  VariableDefinition: {
-    leave: ({ variable, type, defaultValue, directives, description }) => wrap("", description, `
-`) + variable + ": " + type + wrap(" = ", defaultValue) + wrap(" ", join(directives, " "))
-  },
-  SelectionSet: {
-    leave: ({ selections }) => block(selections)
-  },
-  Field: {
-    leave({ alias, name, arguments: args, directives, selectionSet }) {
-      const prefix = wrap("", alias, ": ") + name;
-      let argsLine = prefix + wrap("(", join(args, ", "), ")");
-      if (argsLine.length > MAX_LINE_LENGTH) {
-        argsLine = prefix + wrap(`(
-`, indent(join(args, `
-`)), `
-)`);
-      }
-      return join([argsLine, join(directives, " "), selectionSet], " ");
-    }
-  },
-  Argument: {
-    leave: ({ name, value }) => name + ": " + value
-  },
-  FragmentSpread: {
-    leave: ({ name, directives }) => "..." + name + wrap(" ", join(directives, " "))
-  },
-  InlineFragment: {
-    leave: ({ typeCondition, directives, selectionSet }) => join([
-      "...",
-      wrap("on ", typeCondition),
-      join(directives, " "),
-      selectionSet
-    ], " ")
-  },
-  FragmentDefinition: {
-    leave: ({
-      name,
-      typeCondition,
-      variableDefinitions,
-      directives,
-      selectionSet,
-      description
-    }) => wrap("", description, `
-`) + `fragment ${name}${wrap("(", join(variableDefinitions, ", "), ")")} ` + `on ${typeCondition} ${wrap("", join(directives, " "), " ")}` + selectionSet
-  },
-  IntValue: {
-    leave: ({ value }) => value
-  },
-  FloatValue: {
-    leave: ({ value }) => value
-  },
-  StringValue: {
-    leave: ({ value, block: isBlockString }) => isBlockString ? printBlockString(value) : printString(value)
-  },
-  BooleanValue: {
-    leave: ({ value }) => value ? "true" : "false"
-  },
-  NullValue: {
-    leave: () => "null"
-  },
-  EnumValue: {
-    leave: ({ value }) => value
-  },
-  ListValue: {
-    leave: ({ values }) => "[" + join(values, ", ") + "]"
-  },
-  ObjectValue: {
-    leave: ({ fields }) => "{" + join(fields, ", ") + "}"
-  },
-  ObjectField: {
-    leave: ({ name, value }) => name + ": " + value
-  },
-  Directive: {
-    leave: ({ name, arguments: args }) => "@" + name + wrap("(", join(args, ", "), ")")
-  },
-  NamedType: {
-    leave: ({ name }) => name
-  },
-  ListType: {
-    leave: ({ type }) => "[" + type + "]"
-  },
-  NonNullType: {
-    leave: ({ type }) => type + "!"
-  },
-  SchemaDefinition: {
-    leave: ({ description, directives, operationTypes }) => wrap("", description, `
-`) + join(["schema", join(directives, " "), block(operationTypes)], " ")
-  },
-  OperationTypeDefinition: {
-    leave: ({ operation, type }) => operation + ": " + type
-  },
-  ScalarTypeDefinition: {
-    leave: ({ description, name, directives }) => wrap("", description, `
-`) + join(["scalar", name, join(directives, " ")], " ")
-  },
-  ObjectTypeDefinition: {
-    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, `
-`) + join([
-      "type",
-      name,
-      wrap("implements ", join(interfaces, " & ")),
-      join(directives, " "),
-      block(fields)
-    ], " ")
-  },
-  FieldDefinition: {
-    leave: ({ description, name, arguments: args, type, directives }) => wrap("", description, `
-`) + name + (hasMultilineItems(args) ? wrap(`(
-`, indent(join(args, `
-`)), `
-)`) : wrap("(", join(args, ", "), ")")) + ": " + type + wrap(" ", join(directives, " "))
-  },
-  InputValueDefinition: {
-    leave: ({ description, name, type, defaultValue, directives }) => wrap("", description, `
-`) + join([name + ": " + type, wrap("= ", defaultValue), join(directives, " ")], " ")
-  },
-  InterfaceTypeDefinition: {
-    leave: ({ description, name, interfaces, directives, fields }) => wrap("", description, `
-`) + join([
-      "interface",
-      name,
-      wrap("implements ", join(interfaces, " & ")),
-      join(directives, " "),
-      block(fields)
-    ], " ")
-  },
-  UnionTypeDefinition: {
-    leave: ({ description, name, directives, types }) => wrap("", description, `
-`) + join(["union", name, join(directives, " "), wrap("= ", join(types, " | "))], " ")
-  },
-  EnumTypeDefinition: {
-    leave: ({ description, name, directives, values }) => wrap("", description, `
-`) + join(["enum", name, join(directives, " "), block(values)], " ")
-  },
-  EnumValueDefinition: {
-    leave: ({ description, name, directives }) => wrap("", description, `
-`) + join([name, join(directives, " ")], " ")
-  },
-  InputObjectTypeDefinition: {
-    leave: ({ description, name, directives, fields }) => wrap("", description, `
-`) + join(["input", name, join(directives, " "), block(fields)], " ")
-  },
-  DirectiveDefinition: {
-    leave: ({ description, name, arguments: args, repeatable, locations }) => wrap("", description, `
-`) + "directive @" + name + (hasMultilineItems(args) ? wrap(`(
-`, indent(join(args, `
-`)), `
-)`) : wrap("(", join(args, ", "), ")")) + (repeatable ? " repeatable" : "") + " on " + join(locations, " | ")
-  },
-  SchemaExtension: {
-    leave: ({ directives, operationTypes }) => join(["extend schema", join(directives, " "), block(operationTypes)], " ")
-  },
-  ScalarTypeExtension: {
-    leave: ({ name, directives }) => join(["extend scalar", name, join(directives, " ")], " ")
-  },
-  ObjectTypeExtension: {
-    leave: ({ name, interfaces, directives, fields }) => join([
-      "extend type",
-      name,
-      wrap("implements ", join(interfaces, " & ")),
-      join(directives, " "),
-      block(fields)
-    ], " ")
-  },
-  InterfaceTypeExtension: {
-    leave: ({ name, interfaces, directives, fields }) => join([
-      "extend interface",
-      name,
-      wrap("implements ", join(interfaces, " & ")),
-      join(directives, " "),
-      block(fields)
-    ], " ")
-  },
-  UnionTypeExtension: {
-    leave: ({ name, directives, types }) => join([
-      "extend union",
-      name,
-      join(directives, " "),
-      wrap("= ", join(types, " | "))
-    ], " ")
-  },
-  EnumTypeExtension: {
-    leave: ({ name, directives, values }) => join(["extend enum", name, join(directives, " "), block(values)], " ")
-  },
-  InputObjectTypeExtension: {
-    leave: ({ name, directives, fields }) => join(["extend input", name, join(directives, " "), block(fields)], " ")
-  },
-  TypeCoordinate: {
-    leave: ({ name }) => name
-  },
-  MemberCoordinate: {
-    leave: ({ name, memberName }) => join([name, wrap(".", memberName)])
-  },
-  ArgumentCoordinate: {
-    leave: ({ name, fieldName, argumentName }) => join([name, wrap(".", fieldName), wrap("(", argumentName, ":)")])
-  },
-  DirectiveCoordinate: {
-    leave: ({ name }) => join(["@", name])
-  },
-  DirectiveArgumentCoordinate: {
-    leave: ({ name, argumentName }) => join(["@", name, wrap("(", argumentName, ":)")])
-  }
-};
-function join(maybeArray, separator = "") {
-  var _maybeArray$filter$jo;
-  return (_maybeArray$filter$jo = maybeArray === null || maybeArray === undefined ? undefined : maybeArray.filter((x) => x).join(separator)) !== null && _maybeArray$filter$jo !== undefined ? _maybeArray$filter$jo : "";
-}
-function block(array) {
-  return wrap(`{
-`, indent(join(array, `
-`)), `
-}`);
-}
-function wrap(start, maybeString, end = "") {
-  return maybeString != null && maybeString !== "" ? start + maybeString + end : "";
-}
-function indent(str) {
-  return wrap("  ", str.replace(/\n/g, `
-  `));
-}
-function hasMultilineItems(maybeArray) {
-  var _maybeArray$some;
-  return (_maybeArray$some = maybeArray === null || maybeArray === undefined ? undefined : maybeArray.some((str) => str.includes(`
-`))) !== null && _maybeArray$some !== undefined ? _maybeArray$some : false;
-}
-
-// ../../node_modules/graphql/utilities/valueFromASTUntyped.mjs
-function valueFromASTUntyped(valueNode, variables) {
-  switch (valueNode.kind) {
-    case Kind.NULL:
-      return null;
-    case Kind.INT:
-      return parseInt(valueNode.value, 10);
-    case Kind.FLOAT:
-      return parseFloat(valueNode.value);
-    case Kind.STRING:
-    case Kind.ENUM:
-    case Kind.BOOLEAN:
-      return valueNode.value;
-    case Kind.LIST:
-      return valueNode.values.map((node) => valueFromASTUntyped(node, variables));
-    case Kind.OBJECT:
-      return keyValMap(valueNode.fields, (field) => field.name.value, (field) => valueFromASTUntyped(field.value, variables));
-    case Kind.VARIABLE:
-      return variables === null || variables === undefined ? undefined : variables[valueNode.name.value];
-  }
-}
-
-// ../../node_modules/graphql/type/assertName.mjs
-function assertName(name) {
-  name != null || devAssert(false, "Must provide name.");
-  typeof name === "string" || devAssert(false, "Expected name to be a string.");
-  if (name.length === 0) {
-    throw new GraphQLError("Expected name to be a non-empty string.");
-  }
-  for (let i = 1;i < name.length; ++i) {
-    if (!isNameContinue(name.charCodeAt(i))) {
-      throw new GraphQLError(`Names must only contain [_a-zA-Z0-9] but "${name}" does not.`);
-    }
-  }
-  if (!isNameStart(name.charCodeAt(0))) {
-    throw new GraphQLError(`Names must start with [_a-zA-Z] but "${name}" does not.`);
-  }
-  return name;
-}
-function assertEnumValueName(name) {
-  if (name === "true" || name === "false" || name === "null") {
-    throw new GraphQLError(`Enum values cannot be named: ${name}`);
-  }
-  return assertName(name);
-}
-
-// ../../node_modules/graphql/type/definition.mjs
-function isType(type) {
-  return isScalarType(type) || isObjectType(type) || isInterfaceType(type) || isUnionType(type) || isEnumType(type) || isInputObjectType(type) || isListType(type) || isNonNullType(type);
-}
-function isScalarType(type) {
-  return instanceOf(type, GraphQLScalarType);
-}
-function isObjectType(type) {
-  return instanceOf(type, GraphQLObjectType);
-}
-function isInterfaceType(type) {
-  return instanceOf(type, GraphQLInterfaceType);
-}
-function isUnionType(type) {
-  return instanceOf(type, GraphQLUnionType);
-}
-function isEnumType(type) {
-  return instanceOf(type, GraphQLEnumType);
-}
-function isInputObjectType(type) {
-  return instanceOf(type, GraphQLInputObjectType);
-}
-function isListType(type) {
-  return instanceOf(type, GraphQLList);
-}
-function isNonNullType(type) {
-  return instanceOf(type, GraphQLNonNull);
-}
-function isLeafType(type) {
-  return isScalarType(type) || isEnumType(type);
-}
-function isAbstractType(type) {
-  return isInterfaceType(type) || isUnionType(type);
-}
-class GraphQLList {
-  constructor(ofType) {
-    isType(ofType) || devAssert(false, `Expected ${inspect(ofType)} to be a GraphQL type.`);
-    this.ofType = ofType;
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLList";
-  }
-  toString() {
-    return "[" + String(this.ofType) + "]";
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-
-class GraphQLNonNull {
-  constructor(ofType) {
-    isNullableType(ofType) || devAssert(false, `Expected ${inspect(ofType)} to be a GraphQL nullable type.`);
-    this.ofType = ofType;
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLNonNull";
-  }
-  toString() {
-    return String(this.ofType) + "!";
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-function isWrappingType(type) {
-  return isListType(type) || isNonNullType(type);
-}
-function isNullableType(type) {
-  return isType(type) && !isNonNullType(type);
-}
-function getNamedType(type) {
-  if (type) {
-    let unwrappedType = type;
-    while (isWrappingType(unwrappedType)) {
-      unwrappedType = unwrappedType.ofType;
-    }
-    return unwrappedType;
-  }
-}
-function resolveReadonlyArrayThunk(thunk) {
-  return typeof thunk === "function" ? thunk() : thunk;
-}
-function resolveObjMapThunk(thunk) {
-  return typeof thunk === "function" ? thunk() : thunk;
-}
-
-class GraphQLScalarType {
-  constructor(config) {
-    var _config$parseValue, _config$serialize, _config$parseLiteral, _config$extensionASTN;
-    const parseValue = (_config$parseValue = config.parseValue) !== null && _config$parseValue !== undefined ? _config$parseValue : identityFunc;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.specifiedByURL = config.specifiedByURL;
-    this.serialize = (_config$serialize = config.serialize) !== null && _config$serialize !== undefined ? _config$serialize : identityFunc;
-    this.parseValue = parseValue;
-    this.parseLiteral = (_config$parseLiteral = config.parseLiteral) !== null && _config$parseLiteral !== undefined ? _config$parseLiteral : (node, variables) => parseValue(valueFromASTUntyped(node, variables));
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN = config.extensionASTNodes) !== null && _config$extensionASTN !== undefined ? _config$extensionASTN : [];
-    config.specifiedByURL == null || typeof config.specifiedByURL === "string" || devAssert(false, `${this.name} must provide "specifiedByURL" as a string, ` + `but got: ${inspect(config.specifiedByURL)}.`);
-    config.serialize == null || typeof config.serialize === "function" || devAssert(false, `${this.name} must provide "serialize" function. If this custom Scalar is also used as an input type, ensure "parseValue" and "parseLiteral" functions are also provided.`);
-    if (config.parseLiteral) {
-      typeof config.parseValue === "function" && typeof config.parseLiteral === "function" || devAssert(false, `${this.name} must provide both "parseValue" and "parseLiteral" functions.`);
-    }
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLScalarType";
-  }
-  toConfig() {
-    return {
-      name: this.name,
-      description: this.description,
-      specifiedByURL: this.specifiedByURL,
-      serialize: this.serialize,
-      parseValue: this.parseValue,
-      parseLiteral: this.parseLiteral,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes
-    };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-
-class GraphQLObjectType {
-  constructor(config) {
-    var _config$extensionASTN2;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.isTypeOf = config.isTypeOf;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN2 = config.extensionASTNodes) !== null && _config$extensionASTN2 !== undefined ? _config$extensionASTN2 : [];
-    this._fields = () => defineFieldMap(config);
-    this._interfaces = () => defineInterfaces(config);
-    config.isTypeOf == null || typeof config.isTypeOf === "function" || devAssert(false, `${this.name} must provide "isTypeOf" as a function, ` + `but got: ${inspect(config.isTypeOf)}.`);
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLObjectType";
-  }
-  getFields() {
-    if (typeof this._fields === "function") {
-      this._fields = this._fields();
-    }
-    return this._fields;
-  }
-  getInterfaces() {
-    if (typeof this._interfaces === "function") {
-      this._interfaces = this._interfaces();
-    }
-    return this._interfaces;
-  }
-  toConfig() {
-    return {
-      name: this.name,
-      description: this.description,
-      interfaces: this.getInterfaces(),
-      fields: fieldsToFieldsConfig(this.getFields()),
-      isTypeOf: this.isTypeOf,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes
-    };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-function defineInterfaces(config) {
-  var _config$interfaces;
-  const interfaces = resolveReadonlyArrayThunk((_config$interfaces = config.interfaces) !== null && _config$interfaces !== undefined ? _config$interfaces : []);
-  Array.isArray(interfaces) || devAssert(false, `${config.name} interfaces must be an Array or a function which returns an Array.`);
-  return interfaces;
-}
-function defineFieldMap(config) {
-  const fieldMap = resolveObjMapThunk(config.fields);
-  isPlainObj(fieldMap) || devAssert(false, `${config.name} fields must be an object with field names as keys or a function which returns such an object.`);
-  return mapValue(fieldMap, (fieldConfig, fieldName) => {
-    var _fieldConfig$args;
-    isPlainObj(fieldConfig) || devAssert(false, `${config.name}.${fieldName} field config must be an object.`);
-    fieldConfig.resolve == null || typeof fieldConfig.resolve === "function" || devAssert(false, `${config.name}.${fieldName} field resolver must be a function if ` + `provided, but got: ${inspect(fieldConfig.resolve)}.`);
-    const argsConfig = (_fieldConfig$args = fieldConfig.args) !== null && _fieldConfig$args !== undefined ? _fieldConfig$args : {};
-    isPlainObj(argsConfig) || devAssert(false, `${config.name}.${fieldName} args must be an object with argument names as keys.`);
-    return {
-      name: assertName(fieldName),
-      description: fieldConfig.description,
-      type: fieldConfig.type,
-      args: defineArguments(argsConfig),
-      resolve: fieldConfig.resolve,
-      subscribe: fieldConfig.subscribe,
-      deprecationReason: fieldConfig.deprecationReason,
-      extensions: toObjMap(fieldConfig.extensions),
-      astNode: fieldConfig.astNode
-    };
-  });
-}
-function defineArguments(config) {
-  return Object.entries(config).map(([argName, argConfig]) => ({
-    name: assertName(argName),
-    description: argConfig.description,
-    type: argConfig.type,
-    defaultValue: argConfig.defaultValue,
-    deprecationReason: argConfig.deprecationReason,
-    extensions: toObjMap(argConfig.extensions),
-    astNode: argConfig.astNode
-  }));
-}
-function isPlainObj(obj) {
-  return isObjectLike(obj) && !Array.isArray(obj);
-}
-function fieldsToFieldsConfig(fields) {
-  return mapValue(fields, (field) => ({
-    description: field.description,
-    type: field.type,
-    args: argsToArgsConfig(field.args),
-    resolve: field.resolve,
-    subscribe: field.subscribe,
-    deprecationReason: field.deprecationReason,
-    extensions: field.extensions,
-    astNode: field.astNode
-  }));
-}
-function argsToArgsConfig(args) {
-  return keyValMap(args, (arg) => arg.name, (arg) => ({
-    description: arg.description,
-    type: arg.type,
-    defaultValue: arg.defaultValue,
-    deprecationReason: arg.deprecationReason,
-    extensions: arg.extensions,
-    astNode: arg.astNode
-  }));
-}
-class GraphQLInterfaceType {
-  constructor(config) {
-    var _config$extensionASTN3;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.resolveType = config.resolveType;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN3 = config.extensionASTNodes) !== null && _config$extensionASTN3 !== undefined ? _config$extensionASTN3 : [];
-    this._fields = defineFieldMap.bind(undefined, config);
-    this._interfaces = defineInterfaces.bind(undefined, config);
-    config.resolveType == null || typeof config.resolveType === "function" || devAssert(false, `${this.name} must provide "resolveType" as a function, ` + `but got: ${inspect(config.resolveType)}.`);
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLInterfaceType";
-  }
-  getFields() {
-    if (typeof this._fields === "function") {
-      this._fields = this._fields();
-    }
-    return this._fields;
-  }
-  getInterfaces() {
-    if (typeof this._interfaces === "function") {
-      this._interfaces = this._interfaces();
-    }
-    return this._interfaces;
-  }
-  toConfig() {
-    return {
-      name: this.name,
-      description: this.description,
-      interfaces: this.getInterfaces(),
-      fields: fieldsToFieldsConfig(this.getFields()),
-      resolveType: this.resolveType,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes
-    };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-
-class GraphQLUnionType {
-  constructor(config) {
-    var _config$extensionASTN4;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.resolveType = config.resolveType;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN4 = config.extensionASTNodes) !== null && _config$extensionASTN4 !== undefined ? _config$extensionASTN4 : [];
-    this._types = defineTypes.bind(undefined, config);
-    config.resolveType == null || typeof config.resolveType === "function" || devAssert(false, `${this.name} must provide "resolveType" as a function, ` + `but got: ${inspect(config.resolveType)}.`);
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLUnionType";
-  }
-  getTypes() {
-    if (typeof this._types === "function") {
-      this._types = this._types();
-    }
-    return this._types;
-  }
-  toConfig() {
-    return {
-      name: this.name,
-      description: this.description,
-      types: this.getTypes(),
-      resolveType: this.resolveType,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes
-    };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-function defineTypes(config) {
-  const types = resolveReadonlyArrayThunk(config.types);
-  Array.isArray(types) || devAssert(false, `Must provide Array of types or a function which returns such an array for Union ${config.name}.`);
-  return types;
-}
-
-class GraphQLEnumType {
-  constructor(config) {
-    var _config$extensionASTN5;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN5 = config.extensionASTNodes) !== null && _config$extensionASTN5 !== undefined ? _config$extensionASTN5 : [];
-    this._values = typeof config.values === "function" ? config.values : defineEnumValues(this.name, config.values);
-    this._valueLookup = null;
-    this._nameLookup = null;
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLEnumType";
-  }
-  getValues() {
-    if (typeof this._values === "function") {
-      this._values = defineEnumValues(this.name, this._values());
-    }
-    return this._values;
-  }
-  getValue(name) {
-    if (this._nameLookup === null) {
-      this._nameLookup = keyMap(this.getValues(), (value) => value.name);
-    }
-    return this._nameLookup[name];
-  }
-  serialize(outputValue) {
-    if (this._valueLookup === null) {
-      this._valueLookup = new Map(this.getValues().map((enumValue) => [enumValue.value, enumValue]));
-    }
-    const enumValue = this._valueLookup.get(outputValue);
-    if (enumValue === undefined) {
-      throw new GraphQLError(`Enum "${this.name}" cannot represent value: ${inspect(outputValue)}`);
-    }
-    return enumValue.name;
-  }
-  parseValue(inputValue) {
-    if (typeof inputValue !== "string") {
-      const valueStr = inspect(inputValue);
-      throw new GraphQLError(`Enum "${this.name}" cannot represent non-string value: ${valueStr}.` + didYouMeanEnumValue(this, valueStr));
-    }
-    const enumValue = this.getValue(inputValue);
-    if (enumValue == null) {
-      throw new GraphQLError(`Value "${inputValue}" does not exist in "${this.name}" enum.` + didYouMeanEnumValue(this, inputValue));
-    }
-    return enumValue.value;
-  }
-  parseLiteral(valueNode, _variables) {
-    if (valueNode.kind !== Kind.ENUM) {
-      const valueStr = print(valueNode);
-      throw new GraphQLError(`Enum "${this.name}" cannot represent non-enum value: ${valueStr}.` + didYouMeanEnumValue(this, valueStr), {
-        nodes: valueNode
-      });
-    }
-    const enumValue = this.getValue(valueNode.value);
-    if (enumValue == null) {
-      const valueStr = print(valueNode);
-      throw new GraphQLError(`Value "${valueStr}" does not exist in "${this.name}" enum.` + didYouMeanEnumValue(this, valueStr), {
-        nodes: valueNode
-      });
-    }
-    return enumValue.value;
-  }
-  toConfig() {
-    const values = keyValMap(this.getValues(), (value) => value.name, (value) => ({
-      description: value.description,
-      value: value.value,
-      deprecationReason: value.deprecationReason,
-      extensions: value.extensions,
-      astNode: value.astNode
-    }));
-    return {
-      name: this.name,
-      description: this.description,
-      values,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes
-    };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-function didYouMeanEnumValue(enumType, unknownValueStr) {
-  const allNames = enumType.getValues().map((value) => value.name);
-  const suggestedValues = suggestionList(unknownValueStr, allNames);
-  return didYouMean("the enum value", suggestedValues);
-}
-function defineEnumValues(typeName, valueMap) {
-  isPlainObj(valueMap) || devAssert(false, `${typeName} values must be an object with value names as keys.`);
-  return Object.entries(valueMap).map(([valueName, valueConfig]) => {
-    isPlainObj(valueConfig) || devAssert(false, `${typeName}.${valueName} must refer to an object with a "value" key ` + `representing an internal value but got: ${inspect(valueConfig)}.`);
-    return {
-      name: assertEnumValueName(valueName),
-      description: valueConfig.description,
-      value: valueConfig.value !== undefined ? valueConfig.value : valueName,
-      deprecationReason: valueConfig.deprecationReason,
-      extensions: toObjMap(valueConfig.extensions),
-      astNode: valueConfig.astNode
-    };
-  });
-}
-
-class GraphQLInputObjectType {
-  constructor(config) {
-    var _config$extensionASTN6, _config$isOneOf;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN6 = config.extensionASTNodes) !== null && _config$extensionASTN6 !== undefined ? _config$extensionASTN6 : [];
-    this.isOneOf = (_config$isOneOf = config.isOneOf) !== null && _config$isOneOf !== undefined ? _config$isOneOf : false;
-    this._fields = defineInputFieldMap.bind(undefined, config);
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLInputObjectType";
-  }
-  getFields() {
-    if (typeof this._fields === "function") {
-      this._fields = this._fields();
-    }
-    return this._fields;
-  }
-  toConfig() {
-    const fields = mapValue(this.getFields(), (field) => ({
-      description: field.description,
-      type: field.type,
-      defaultValue: field.defaultValue,
-      deprecationReason: field.deprecationReason,
-      extensions: field.extensions,
-      astNode: field.astNode
-    }));
-    return {
-      name: this.name,
-      description: this.description,
-      fields,
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes,
-      isOneOf: this.isOneOf
+import {
+  GraphQLSchema as GraphQLSchema4,
+  GraphQLObjectType as GraphQLObjectType2,
+  GraphQLString as GraphQLString2,
+  GraphQLNonNull as GraphQLNonNull2,
+  GraphQLList as GraphQLList2,
+  GraphQLUnionType,
+  printSchema
+} from "graphql";
+
+// ../graphql/src/decorators/type.decorators.ts
+import"reflect-metadata";
+var OBJECT_TYPE_METADATA = "graphql:objectType";
+var INPUT_TYPE_METADATA = "graphql:inputType";
+var FIELD_METADATA = "graphql:field";
+// ../graphql/src/decorators/resolver.decorators.ts
+import"reflect-metadata";
+var QUERY_METADATA = "graphql:query";
+var MUTATION_METADATA = "graphql:mutation";
+var SUBSCRIPTION_METADATA = "graphql:subscription";
+// ../graphql/src/decorators/param.decorators.ts
+import"reflect-metadata";
+function createParamDecorator(type) {
+  return (options) => {
+    return (target, propertyKey, parameterIndex) => {
+      const metadataKey = `graphql:params:${String(propertyKey)}`;
+      const existingParams = Reflect.getMetadata(metadataKey, target.constructor) || [];
+      existingParams.push({
+        index: parameterIndex,
+        type,
+        options
+      });
+      Reflect.defineMetadata(metadataKey, existingParams, target.constructor);
     };
-  }
-  toString() {
-    return this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
+  };
 }
-function defineInputFieldMap(config) {
-  const fieldMap = resolveObjMapThunk(config.fields);
-  isPlainObj(fieldMap) || devAssert(false, `${config.name} fields must be an object with field names as keys or a function which returns such an object.`);
-  return mapValue(fieldMap, (fieldConfig, fieldName) => {
-    !("resolve" in fieldConfig) || devAssert(false, `${config.name}.${fieldName} field has a resolve property, but Input Types cannot define resolvers.`);
-    return {
-      name: assertName(fieldName),
-      description: fieldConfig.description,
-      type: fieldConfig.type,
-      defaultValue: fieldConfig.defaultValue,
-      deprecationReason: fieldConfig.deprecationReason,
-      extensions: toObjMap(fieldConfig.extensions),
-      astNode: fieldConfig.astNode
-    };
-  });
+var Context = createParamDecorator("context");
+var Root = createParamDecorator("root");
+var Parent = createParamDecorator("parent");
+var Info = createParamDecorator("info");
+function getParamsMetadata(target, methodName) {
+  return Reflect.getMetadata(`graphql:params:${methodName}`, target) || [];
 }
-
-// ../../node_modules/graphql/language/directiveLocation.mjs
-var DirectiveLocation;
-(function(DirectiveLocation) {
-  DirectiveLocation["QUERY"] = "QUERY";
-  DirectiveLocation["MUTATION"] = "MUTATION";
-  DirectiveLocation["SUBSCRIPTION"] = "SUBSCRIPTION";
-  DirectiveLocation["FIELD"] = "FIELD";
-  DirectiveLocation["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
-  DirectiveLocation["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
-  DirectiveLocation["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
-  DirectiveLocation["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
-  DirectiveLocation["SCHEMA"] = "SCHEMA";
-  DirectiveLocation["SCALAR"] = "SCALAR";
-  DirectiveLocation["OBJECT"] = "OBJECT";
-  DirectiveLocation["FIELD_DEFINITION"] = "FIELD_DEFINITION";
-  DirectiveLocation["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
-  DirectiveLocation["INTERFACE"] = "INTERFACE";
-  DirectiveLocation["UNION"] = "UNION";
-  DirectiveLocation["ENUM"] = "ENUM";
-  DirectiveLocation["ENUM_VALUE"] = "ENUM_VALUE";
-  DirectiveLocation["INPUT_OBJECT"] = "INPUT_OBJECT";
-  DirectiveLocation["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
-})(DirectiveLocation || (DirectiveLocation = {}));
-
-// ../../node_modules/graphql/type/scalars.mjs
-var GRAPHQL_MAX_INT = 2147483647;
-var GRAPHQL_MIN_INT = -2147483648;
-var GraphQLInt = new GraphQLScalarType({
-  name: "Int",
-  description: "The `Int` scalar type represents non-fractional signed whole numeric values. Int can represent values between -(2^31) and 2^31 - 1.",
-  serialize(outputValue) {
-    const coercedValue = serializeObject(outputValue);
-    if (typeof coercedValue === "boolean") {
-      return coercedValue ? 1 : 0;
-    }
-    let num = coercedValue;
-    if (typeof coercedValue === "string" && coercedValue !== "") {
-      num = Number(coercedValue);
-    }
-    if (typeof num !== "number" || !Number.isInteger(num)) {
-      throw new GraphQLError(`Int cannot represent non-integer value: ${inspect(coercedValue)}`);
-    }
-    if (num > GRAPHQL_MAX_INT || num < GRAPHQL_MIN_INT) {
-      throw new GraphQLError("Int cannot represent non 32-bit signed integer value: " + inspect(coercedValue));
-    }
-    return num;
-  },
-  parseValue(inputValue) {
-    if (typeof inputValue !== "number" || !Number.isInteger(inputValue)) {
-      throw new GraphQLError(`Int cannot represent non-integer value: ${inspect(inputValue)}`);
-    }
-    if (inputValue > GRAPHQL_MAX_INT || inputValue < GRAPHQL_MIN_INT) {
-      throw new GraphQLError(`Int cannot represent non 32-bit signed integer value: ${inputValue}`);
-    }
-    return inputValue;
-  },
-  parseLiteral(valueNode) {
-    if (valueNode.kind !== Kind.INT) {
-      throw new GraphQLError(`Int cannot represent non-integer value: ${print(valueNode)}`, {
-        nodes: valueNode
-      });
-    }
-    const num = parseInt(valueNode.value, 10);
-    if (num > GRAPHQL_MAX_INT || num < GRAPHQL_MIN_INT) {
-      throw new GraphQLError(`Int cannot represent non 32-bit signed integer value: ${valueNode.value}`, {
-        nodes: valueNode
-      });
-    }
-    return num;
-  }
-});
-var GraphQLFloat = new GraphQLScalarType({
-  name: "Float",
-  description: "The `Float` scalar type represents signed double-precision fractional values as specified by [IEEE 754](https://en.wikipedia.org/wiki/IEEE_floating_point).",
-  serialize(outputValue) {
-    const coercedValue = serializeObject(outputValue);
-    if (typeof coercedValue === "boolean") {
-      return coercedValue ? 1 : 0;
-    }
-    let num = coercedValue;
-    if (typeof coercedValue === "string" && coercedValue !== "") {
-      num = Number(coercedValue);
-    }
-    if (typeof num !== "number" || !Number.isFinite(num)) {
-      throw new GraphQLError(`Float cannot represent non numeric value: ${inspect(coercedValue)}`);
-    }
-    return num;
-  },
-  parseValue(inputValue) {
-    if (typeof inputValue !== "number" || !Number.isFinite(inputValue)) {
-      throw new GraphQLError(`Float cannot represent non numeric value: ${inspect(inputValue)}`);
-    }
-    return inputValue;
-  },
-  parseLiteral(valueNode) {
-    if (valueNode.kind !== Kind.FLOAT && valueNode.kind !== Kind.INT) {
-      throw new GraphQLError(`Float cannot represent non numeric value: ${print(valueNode)}`, valueNode);
-    }
-    return parseFloat(valueNode.value);
-  }
-});
-var GraphQLString = new GraphQLScalarType({
-  name: "String",
-  description: "The `String` scalar type represents textual data, represented as UTF-8 character sequences. The String type is most often used by GraphQL to represent free-form human-readable text.",
-  serialize(outputValue) {
-    const coercedValue = serializeObject(outputValue);
-    if (typeof coercedValue === "string") {
-      return coercedValue;
-    }
-    if (typeof coercedValue === "boolean") {
-      return coercedValue ? "true" : "false";
-    }
-    if (typeof coercedValue === "number" && Number.isFinite(coercedValue)) {
-      return coercedValue.toString();
-    }
-    throw new GraphQLError(`String cannot represent value: ${inspect(outputValue)}`);
-  },
-  parseValue(inputValue) {
-    if (typeof inputValue !== "string") {
-      throw new GraphQLError(`String cannot represent a non string value: ${inspect(inputValue)}`);
-    }
-    return inputValue;
-  },
-  parseLiteral(valueNode) {
-    if (valueNode.kind !== Kind.STRING) {
-      throw new GraphQLError(`String cannot represent a non string value: ${print(valueNode)}`, {
-        nodes: valueNode
-      });
-    }
-    return valueNode.value;
-  }
-});
-var GraphQLBoolean = new GraphQLScalarType({
-  name: "Boolean",
-  description: "The `Boolean` scalar type represents `true` or `false`.",
-  serialize(outputValue) {
-    const coercedValue = serializeObject(outputValue);
-    if (typeof coercedValue === "boolean") {
-      return coercedValue;
-    }
-    if (Number.isFinite(coercedValue)) {
-      return coercedValue !== 0;
-    }
-    throw new GraphQLError(`Boolean cannot represent a non boolean value: ${inspect(coercedValue)}`);
-  },
-  parseValue(inputValue) {
-    if (typeof inputValue !== "boolean") {
-      throw new GraphQLError(`Boolean cannot represent a non boolean value: ${inspect(inputValue)}`);
-    }
-    return inputValue;
-  },
-  parseLiteral(valueNode) {
-    if (valueNode.kind !== Kind.BOOLEAN) {
-      throw new GraphQLError(`Boolean cannot represent a non boolean value: ${print(valueNode)}`, {
-        nodes: valueNode
-      });
-    }
-    return valueNode.value;
-  }
-});
-var GraphQLID = new GraphQLScalarType({
-  name: "ID",
-  description: 'The `ID` scalar type represents a unique identifier, often used to refetch an object or as key for a cache. The ID type appears in a JSON response as a String; however, it is not intended to be human-readable. When expected as an input type, any string (such as `"4"`) or integer (such as `4`) input value will be accepted as an ID.',
-  serialize(outputValue) {
-    const coercedValue = serializeObject(outputValue);
-    if (typeof coercedValue === "string") {
-      return coercedValue;
-    }
-    if (Number.isInteger(coercedValue)) {
-      return String(coercedValue);
-    }
-    throw new GraphQLError(`ID cannot represent value: ${inspect(outputValue)}`);
-  },
-  parseValue(inputValue) {
-    if (typeof inputValue === "string") {
-      return inputValue;
-    }
-    if (typeof inputValue === "number" && Number.isInteger(inputValue)) {
-      return inputValue.toString();
-    }
-    throw new GraphQLError(`ID cannot represent value: ${inspect(inputValue)}`);
-  },
-  parseLiteral(valueNode) {
-    if (valueNode.kind !== Kind.STRING && valueNode.kind !== Kind.INT) {
-      throw new GraphQLError("ID cannot represent a non-string and non-integer value: " + print(valueNode), {
-        nodes: valueNode
-      });
-    }
-    return valueNode.value;
-  }
-});
-var specifiedScalarTypes = Object.freeze([
+// ../graphql/src/schema/schema-builder.ts
+import"reflect-metadata";
+import {
+  GraphQLSchema,
+  GraphQLObjectType,
+  GraphQLInputObjectType,
   GraphQLString,
   GraphQLInt,
   GraphQLFloat,
   GraphQLBoolean,
-  GraphQLID
-]);
-function isSpecifiedScalarType(type) {
-  return specifiedScalarTypes.some(({ name }) => type.name === name);
-}
-function serializeObject(outputValue) {
-  if (isObjectLike(outputValue)) {
-    if (typeof outputValue.valueOf === "function") {
-      const valueOfResult = outputValue.valueOf();
-      if (!isObjectLike(valueOfResult)) {
-        return valueOfResult;
-      }
-    }
-    if (typeof outputValue.toJSON === "function") {
-      return outputValue.toJSON();
-    }
-  }
-  return outputValue;
-}
+  GraphQLID,
+  GraphQLList,
+  GraphQLNonNull
+} from "graphql";
 
-// ../../node_modules/graphql/type/directives.mjs
-function isDirective(directive) {
-  return instanceOf(directive, GraphQLDirective);
-}
-class GraphQLDirective {
-  constructor(config) {
-    var _config$isRepeatable, _config$args;
-    this.name = assertName(config.name);
-    this.description = config.description;
-    this.locations = config.locations;
-    this.isRepeatable = (_config$isRepeatable = config.isRepeatable) !== null && _config$isRepeatable !== undefined ? _config$isRepeatable : false;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    Array.isArray(config.locations) || devAssert(false, `@${config.name} locations must be an Array.`);
-    const args = (_config$args = config.args) !== null && _config$args !== undefined ? _config$args : {};
-    isObjectLike(args) && !Array.isArray(args) || devAssert(false, `@${config.name} args must be an object with argument names as keys.`);
-    this.args = defineArguments(args);
-  }
-  get [Symbol.toStringTag]() {
-    return "GraphQLDirective";
-  }
-  toConfig() {
-    return {
-      name: this.name,
-      description: this.description,
-      locations: this.locations,
-      args: argsToArgsConfig(this.args),
-      isRepeatable: this.isRepeatable,
-      extensions: this.extensions,
-      astNode: this.astNode
-    };
-  }
-  toString() {
-    return "@" + this.name;
-  }
-  toJSON() {
-    return this.toString();
-  }
-}
-var GraphQLIncludeDirective = new GraphQLDirective({
-  name: "include",
-  description: "Directs the executor to include this field or fragment only when the `if` argument is true.",
-  locations: [
-    DirectiveLocation.FIELD,
-    DirectiveLocation.FRAGMENT_SPREAD,
-    DirectiveLocation.INLINE_FRAGMENT
-  ],
-  args: {
-    if: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      description: "Included when true."
-    }
-  }
-});
-var GraphQLSkipDirective = new GraphQLDirective({
-  name: "skip",
-  description: "Directs the executor to skip this field or fragment when the `if` argument is true.",
-  locations: [
-    DirectiveLocation.FIELD,
-    DirectiveLocation.FRAGMENT_SPREAD,
-    DirectiveLocation.INLINE_FRAGMENT
-  ],
-  args: {
-    if: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      description: "Skipped when true."
-    }
-  }
-});
-var DEFAULT_DEPRECATION_REASON = "No longer supported";
-var GraphQLDeprecatedDirective = new GraphQLDirective({
-  name: "deprecated",
-  description: "Marks an element of a GraphQL schema as no longer supported.",
-  locations: [
-    DirectiveLocation.FIELD_DEFINITION,
-    DirectiveLocation.ARGUMENT_DEFINITION,
-    DirectiveLocation.INPUT_FIELD_DEFINITION,
-    DirectiveLocation.ENUM_VALUE
-  ],
-  args: {
-    reason: {
-      type: GraphQLString,
-      description: "Explains why this element was deprecated, usually also including a suggestion for how to access supported similar data. Formatted using the Markdown syntax, as specified by [CommonMark](https://commonmark.org/).",
-      defaultValue: DEFAULT_DEPRECATION_REASON
+// ../graphql/src/dataloader/context.ts
+import"reflect-metadata";
+var DATALOADER_METADATA = "graphql:dataloader";
+class DataLoaderContext {
+  loaders = new Map;
+  factories = new Map;
+  registerLoader(name, factory) {
+    this.factories.set(name, factory);
+  }
+  getLoader(name) {
+    if (!this.loaders.has(name)) {
+      const factory = this.factories.get(name);
+      if (!factory) {
+        throw new Error(`DataLoader "${name}" not registered`);
+      }
+      this.loaders.set(name, factory());
+    }
+    return this.loaders.get(name);
+  }
+  clearAll() {
+    for (const loader of this.loaders.values()) {
+      loader.clearAll();
+    }
+    this.loaders.clear();
+  }
+}
+
+// ../graphql/src/schema/schema-builder.ts
+class SchemaBuilder {
+  objectTypes = new Map;
+  inputTypes = new Map;
+  resolvers = [];
+  addResolver(resolver) {
+    this.resolvers.push(resolver);
+  }
+  build() {
+    const queryFields = {};
+    const mutationFields = {};
+    const subscriptionFields = {};
+    for (const resolver of this.resolvers) {
+      const resolverClass = resolver.constructor;
+      const queries = Reflect.getMetadata(QUERY_METADATA, resolverClass) || [];
+      const mutations = Reflect.getMetadata(MUTATION_METADATA, resolverClass) || [];
+      const subscriptions = Reflect.getMetadata(SUBSCRIPTION_METADATA, resolverClass) || [];
+      for (const query of queries) {
+        const fieldName = query.options.name || query.methodName;
+        queryFields[fieldName] = this.buildFieldConfig(resolver, query);
+      }
+      for (const mutation of mutations) {
+        const fieldName = mutation.options.name || mutation.methodName;
+        mutationFields[fieldName] = this.buildFieldConfig(resolver, mutation);
+      }
+      for (const subscription of subscriptions) {
+        const fieldName = subscription.options.name || subscription.methodName;
+        subscriptionFields[fieldName] = this.buildSubscriptionConfig(resolver, subscription);
+      }
+    }
+    const schemaConfig = {};
+    if (Object.keys(queryFields).length > 0) {
+      schemaConfig.query = new GraphQLObjectType({
+        name: "Query",
+        fields: queryFields
+      });
     }
-  }
-});
-var GraphQLSpecifiedByDirective = new GraphQLDirective({
-  name: "specifiedBy",
-  description: "Exposes a URL that specifies the behavior of this scalar.",
-  locations: [DirectiveLocation.SCALAR],
-  args: {
-    url: {
-      type: new GraphQLNonNull(GraphQLString),
-      description: "The URL that specifies the behavior of this scalar."
+    if (Object.keys(mutationFields).length > 0) {
+      schemaConfig.mutation = new GraphQLObjectType({
+        name: "Mutation",
+        fields: mutationFields
+      });
     }
-  }
-});
-var GraphQLOneOfDirective = new GraphQLDirective({
-  name: "oneOf",
-  description: "Indicates exactly one field must be supplied and this field must not be `null`.",
-  locations: [DirectiveLocation.INPUT_OBJECT],
-  args: {}
-});
-var specifiedDirectives = Object.freeze([
-  GraphQLIncludeDirective,
-  GraphQLSkipDirective,
-  GraphQLDeprecatedDirective,
-  GraphQLSpecifiedByDirective,
-  GraphQLOneOfDirective
-]);
-function isSpecifiedDirective(directive) {
-  return specifiedDirectives.some(({ name }) => name === directive.name);
-}
-
-// ../../node_modules/graphql/jsutils/isIterableObject.mjs
-function isIterableObject(maybeIterable) {
-  return typeof maybeIterable === "object" && typeof (maybeIterable === null || maybeIterable === undefined ? undefined : maybeIterable[Symbol.iterator]) === "function";
-}
-
-// ../../node_modules/graphql/utilities/astFromValue.mjs
-function astFromValue(value, type) {
-  if (isNonNullType(type)) {
-    const astValue = astFromValue(value, type.ofType);
-    if ((astValue === null || astValue === undefined ? undefined : astValue.kind) === Kind.NULL) {
-      return null;
+    if (Object.keys(subscriptionFields).length > 0) {
+      schemaConfig.subscription = new GraphQLObjectType({
+        name: "Subscription",
+        fields: subscriptionFields
+      });
     }
-    return astValue;
+    return new GraphQLSchema(schemaConfig);
   }
-  if (value === null) {
+  buildFieldConfig(resolver, metadata) {
+    const returnType = this.getReturnType(metadata);
     return {
-      kind: Kind.NULL
-    };
-  }
-  if (value === undefined) {
-    return null;
-  }
-  if (isListType(type)) {
-    const itemType = type.ofType;
-    if (isIterableObject(value)) {
-      const valuesNodes = [];
-      for (const item of value) {
-        const itemNode = astFromValue(item, itemType);
-        if (itemNode != null) {
-          valuesNodes.push(itemNode);
-        }
-      }
-      return {
-        kind: Kind.LIST,
-        values: valuesNodes
-      };
-    }
-    return astFromValue(value, itemType);
-  }
-  if (isInputObjectType(type)) {
-    if (!isObjectLike(value)) {
-      return null;
-    }
-    const fieldNodes = [];
-    for (const field of Object.values(type.getFields())) {
-      const fieldValue = astFromValue(value[field.name], field.type);
-      if (fieldValue) {
-        fieldNodes.push({
-          kind: Kind.OBJECT_FIELD,
-          name: {
-            kind: Kind.NAME,
-            value: field.name
-          },
-          value: fieldValue
+      type: returnType,
+      description: metadata.options.description,
+      deprecationReason: metadata.options.deprecationReason,
+      args: this.buildArgs(resolver.constructor, metadata.methodName),
+      resolve: async (root, args, context, info) => {
+        const params = this.resolveParams(resolver.constructor, metadata.methodName, {
+          root,
+          args,
+          context,
+          info
         });
+        return resolver[metadata.methodName](...params);
       }
-    }
+    };
+  }
+  buildSubscriptionConfig(resolver, metadata) {
+    const returnType = this.getReturnType(metadata);
+    const options = metadata.options;
     return {
-      kind: Kind.OBJECT,
-      fields: fieldNodes
+      type: returnType,
+      description: metadata.options.description,
+      args: this.buildArgs(resolver.constructor, metadata.methodName),
+      subscribe: async (root, args, context, info) => {
+        const params = this.resolveParams(resolver.constructor, metadata.methodName, {
+          root,
+          args,
+          context,
+          info
+        });
+        return resolver[metadata.methodName](...params);
+      },
+      resolve: options.resolve || ((payload) => payload)
     };
   }
-  if (isLeafType(type)) {
-    const serialized = type.serialize(value);
-    if (serialized == null) {
-      return null;
-    }
-    if (typeof serialized === "boolean") {
-      return {
-        kind: Kind.BOOLEAN,
-        value: serialized
-      };
-    }
-    if (typeof serialized === "number" && Number.isFinite(serialized)) {
-      const stringNum = String(serialized);
-      return integerStringRegExp.test(stringNum) ? {
-        kind: Kind.INT,
-        value: stringNum
-      } : {
-        kind: Kind.FLOAT,
-        value: stringNum
-      };
-    }
-    if (typeof serialized === "string") {
-      if (isEnumType(type)) {
-        return {
-          kind: Kind.ENUM,
-          value: serialized
-        };
+  getReturnType(metadata) {
+    if (metadata.typeFn) {
+      return this.convertToGraphQLType(metadata.typeFn());
+    }
+    return GraphQLString;
+  }
+  buildArgs(resolverClass, methodName) {
+    const paramsMetadata = getParamsMetadata(resolverClass, methodName);
+    const args = {};
+    for (const param of paramsMetadata) {
+      if (param.type === "args" && param.options) {
+        const options = typeof param.options === "string" ? { name: param.options } : param.options;
+        if (options.name) {
+          args[options.name] = {
+            type: options.type ? this.convertToGraphQLInputType(options.type()) : GraphQLString,
+            description: options.description,
+            defaultValue: options.defaultValue
+          };
+        }
+      }
+    }
+    return args;
+  }
+  resolveParams(resolverClass, methodName, ctx) {
+    const paramsMetadata = getParamsMetadata(resolverClass, methodName);
+    const paramTypes = Reflect.getMetadata("design:paramtypes", resolverClass.prototype, methodName) || [];
+    const params = new Array(paramTypes.length).fill(undefined);
+    const loaderMetadata = Reflect.getMetadata(DATALOADER_METADATA, resolverClass.prototype, methodName) || new Map;
+    for (const param of paramsMetadata) {
+      switch (param.type) {
+        case "args":
+          if (param.options) {
+            const name = typeof param.options === "string" ? param.options : param.options.name;
+            params[param.index] = name ? ctx.args[name] : ctx.args;
+          } else {
+            params[param.index] = ctx.args;
+          }
+          break;
+        case "context":
+          if (typeof param.options === "string") {
+            params[param.index] = ctx.context[param.options];
+          } else {
+            params[param.index] = ctx.context;
+          }
+          break;
+        case "root":
+        case "parent":
+          params[param.index] = ctx.root;
+          break;
+        case "info":
+          params[param.index] = ctx.info;
+          break;
+      }
+    }
+    for (const [index, loaderName] of loaderMetadata) {
+      const loaderContext = ctx.context?.loaders;
+      if (loaderContext) {
+        params[index] = loaderContext.getLoader(loaderName);
+      }
+    }
+    return params;
+  }
+  convertToGraphQLType(type) {
+    if (type === String)
+      return GraphQLString;
+    if (type === Number)
+      return GraphQLFloat;
+    if (type === Boolean)
+      return GraphQLBoolean;
+    if (type === "ID" || type?.name === "ID")
+      return GraphQLID;
+    if (type === "Int")
+      return GraphQLInt;
+    if (type === "Float")
+      return GraphQLFloat;
+    if (Array.isArray(type)) {
+      return new GraphQLList(this.convertToGraphQLType(type[0]));
+    }
+    if (this.objectTypes.has(type)) {
+      return this.objectTypes.get(type);
+    }
+    const objectTypeMeta = Reflect.getMetadata(OBJECT_TYPE_METADATA, type);
+    if (objectTypeMeta) {
+      return this.buildObjectType(type);
+    }
+    return GraphQLString;
+  }
+  convertToGraphQLInputType(type) {
+    if (type === String)
+      return GraphQLString;
+    if (type === Number)
+      return GraphQLFloat;
+    if (type === Boolean)
+      return GraphQLBoolean;
+    if (type === "ID" || type?.name === "ID")
+      return GraphQLID;
+    if (type === "Int")
+      return GraphQLInt;
+    if (type === "Float")
+      return GraphQLFloat;
+    if (Array.isArray(type)) {
+      return new GraphQLList(this.convertToGraphQLInputType(type[0]));
+    }
+    if (this.inputTypes.has(type)) {
+      return this.inputTypes.get(type);
+    }
+    const inputTypeMeta = Reflect.getMetadata(INPUT_TYPE_METADATA, type);
+    if (inputTypeMeta) {
+      return this.buildInputType(type);
+    }
+    return GraphQLString;
+  }
+  buildObjectType(type) {
+    if (this.objectTypes.has(type)) {
+      return this.objectTypes.get(type);
+    }
+    const metadata = Reflect.getMetadata(OBJECT_TYPE_METADATA, type);
+    const fields = Reflect.getMetadata(FIELD_METADATA, type) || [];
+    const objectType = new GraphQLObjectType({
+      name: metadata.name,
+      description: metadata.description,
+      fields: () => {
+        const graphqlFields = {};
+        for (const field of fields) {
+          const fieldType = field.typeFn ? this.convertToGraphQLType(field.typeFn()) : GraphQLString;
+          graphqlFields[field.name || field.propertyKey] = {
+            type: field.nullable ? fieldType : new GraphQLNonNull(fieldType),
+            description: field.description,
+            deprecationReason: field.deprecationReason,
+            resolve: (parent) => parent[field.propertyKey]
+          };
+        }
+        return graphqlFields;
       }
-      if (type === GraphQLID && integerStringRegExp.test(serialized)) {
-        return {
-          kind: Kind.INT,
-          value: serialized
-        };
+    });
+    this.objectTypes.set(type, objectType);
+    return objectType;
+  }
+  buildInputType(type) {
+    if (this.inputTypes.has(type)) {
+      return this.inputTypes.get(type);
+    }
+    const metadata = Reflect.getMetadata(INPUT_TYPE_METADATA, type);
+    const fields = Reflect.getMetadata(FIELD_METADATA, type) || [];
+    const inputType = new GraphQLInputObjectType({
+      name: metadata.name,
+      description: metadata.description,
+      fields: () => {
+        const graphqlFields = {};
+        for (const field of fields) {
+          const fieldType = field.typeFn ? this.convertToGraphQLInputType(field.typeFn()) : GraphQLString;
+          graphqlFields[field.name || field.propertyKey] = {
+            type: field.nullable ? fieldType : new GraphQLNonNull(fieldType),
+            description: field.description,
+            defaultValue: field.defaultValue
+          };
+        }
+        return graphqlFields;
       }
-      return {
-        kind: Kind.STRING,
-        value: serialized
-      };
-    }
-    throw new TypeError(`Cannot convert value to AST: ${inspect(serialized)}.`);
+    });
+    this.inputTypes.set(type, inputType);
+    return inputType;
   }
-  invariant(false, "Unexpected input type: " + inspect(type));
 }
-var integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;
-
-// ../../node_modules/graphql/type/introspection.mjs
-var __Schema = new GraphQLObjectType({
-  name: "__Schema",
-  description: "A GraphQL Schema defines the capabilities of a GraphQL server. It exposes all available types and directives on the server, as well as the entry points for query, mutation, and subscription operations.",
-  fields: () => ({
-    description: {
-      type: GraphQLString,
-      resolve: (schema) => schema.description
-    },
-    types: {
-      description: "A list of all types supported by this server.",
-      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__Type))),
-      resolve(schema) {
-        return Object.values(schema.getTypeMap());
-      }
-    },
-    queryType: {
-      description: "The type that query operations will be rooted at.",
-      type: new GraphQLNonNull(__Type),
-      resolve: (schema) => schema.getQueryType()
-    },
-    mutationType: {
-      description: "If this server supports mutation, the type that mutation operations will be rooted at.",
-      type: __Type,
-      resolve: (schema) => schema.getMutationType()
-    },
-    subscriptionType: {
-      description: "If this server support subscription, the type that subscription operations will be rooted at.",
-      type: __Type,
-      resolve: (schema) => schema.getSubscriptionType()
-    },
-    directives: {
-      description: "A list of all directives supported by this server.",
-      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__Directive))),
-      resolve: (schema) => schema.getDirectives()
-    }
-  })
-});
-var __Directive = new GraphQLObjectType({
-  name: "__Directive",
-  description: `A Directive provides a way to describe alternate runtime execution and type validation behavior in a GraphQL document.
-
-In some cases, you need to provide options to alter GraphQL's execution behavior in ways field arguments will not suffice, such as conditionally including or skipping a field. Directives provide this by describing additional information to the executor.`,
-  fields: () => ({
-    name: {
-      type: new GraphQLNonNull(GraphQLString),
-      resolve: (directive) => directive.name
-    },
-    description: {
-      type: GraphQLString,
-      resolve: (directive) => directive.description
-    },
-    isRepeatable: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      resolve: (directive) => directive.isRepeatable
-    },
-    locations: {
-      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__DirectiveLocation))),
-      resolve: (directive) => directive.locations
-    },
-    args: {
-      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__InputValue))),
-      args: {
-        includeDeprecated: {
-          type: GraphQLBoolean,
-          defaultValue: false
+// ../graphql/src/module/graphql.module.ts
+import"reflect-metadata";
+import { parse, validate, execute } from "graphql";
+var GRAPHQL_OPTIONS = Symbol("GRAPHQL_OPTIONS");
+var GRAPHQL_SCHEMA = Symbol("GRAPHQL_SCHEMA");
+
+class GraphQLModule {
+  static schemaBuilder = new SchemaBuilder;
+  static forRoot(options = {}) {
+    const resolvers = options.resolvers || [];
+    return {
+      module: GraphQLModule,
+      global: true,
+      providers: [
+        {
+          provide: GRAPHQL_OPTIONS,
+          useValue: {
+            path: "/graphql",
+            playground: true,
+            introspection: true,
+            ...options
+          }
+        },
+        {
+          provide: GRAPHQL_SCHEMA,
+          useFactory: () => {
+            for (const resolver of resolvers) {
+              const instance = new resolver;
+              this.schemaBuilder.addResolver(instance);
+            }
+            return this.schemaBuilder.build();
+          }
+        },
+        {
+          provide: "GraphQLHandler",
+          useFactory: (schema, opts) => {
+            return new GraphQLHandler(schema, opts);
+          },
+          inject: [GRAPHQL_SCHEMA, GRAPHQL_OPTIONS]
         }
-      },
-      resolve(field, { includeDeprecated }) {
-        return includeDeprecated ? field.args : field.args.filter((arg) => arg.deprecationReason == null);
-      }
-    }
-  })
-});
-var __DirectiveLocation = new GraphQLEnumType({
-  name: "__DirectiveLocation",
-  description: "A Directive can be adjacent to many parts of the GraphQL language, a __DirectiveLocation describes one such possible adjacencies.",
-  values: {
-    QUERY: {
-      value: DirectiveLocation.QUERY,
-      description: "Location adjacent to a query operation."
-    },
-    MUTATION: {
-      value: DirectiveLocation.MUTATION,
-      description: "Location adjacent to a mutation operation."
-    },
-    SUBSCRIPTION: {
-      value: DirectiveLocation.SUBSCRIPTION,
-      description: "Location adjacent to a subscription operation."
-    },
-    FIELD: {
-      value: DirectiveLocation.FIELD,
-      description: "Location adjacent to a field."
-    },
-    FRAGMENT_DEFINITION: {
-      value: DirectiveLocation.FRAGMENT_DEFINITION,
-      description: "Location adjacent to a fragment definition."
-    },
-    FRAGMENT_SPREAD: {
-      value: DirectiveLocation.FRAGMENT_SPREAD,
-      description: "Location adjacent to a fragment spread."
-    },
-    INLINE_FRAGMENT: {
-      value: DirectiveLocation.INLINE_FRAGMENT,
-      description: "Location adjacent to an inline fragment."
-    },
-    VARIABLE_DEFINITION: {
-      value: DirectiveLocation.VARIABLE_DEFINITION,
-      description: "Location adjacent to a variable definition."
-    },
-    SCHEMA: {
-      value: DirectiveLocation.SCHEMA,
-      description: "Location adjacent to a schema definition."
-    },
-    SCALAR: {
-      value: DirectiveLocation.SCALAR,
-      description: "Location adjacent to a scalar definition."
-    },
-    OBJECT: {
-      value: DirectiveLocation.OBJECT,
-      description: "Location adjacent to an object type definition."
-    },
-    FIELD_DEFINITION: {
-      value: DirectiveLocation.FIELD_DEFINITION,
-      description: "Location adjacent to a field definition."
-    },
-    ARGUMENT_DEFINITION: {
-      value: DirectiveLocation.ARGUMENT_DEFINITION,
-      description: "Location adjacent to an argument definition."
-    },
-    INTERFACE: {
-      value: DirectiveLocation.INTERFACE,
-      description: "Location adjacent to an interface definition."
-    },
-    UNION: {
-      value: DirectiveLocation.UNION,
-      description: "Location adjacent to a union definition."
-    },
-    ENUM: {
-      value: DirectiveLocation.ENUM,
-      description: "Location adjacent to an enum definition."
-    },
-    ENUM_VALUE: {
-      value: DirectiveLocation.ENUM_VALUE,
-      description: "Location adjacent to an enum value definition."
-    },
-    INPUT_OBJECT: {
-      value: DirectiveLocation.INPUT_OBJECT,
-      description: "Location adjacent to an input object type definition."
-    },
-    INPUT_FIELD_DEFINITION: {
-      value: DirectiveLocation.INPUT_FIELD_DEFINITION,
-      description: "Location adjacent to an input object field definition."
-    }
+      ],
+      exports: [GRAPHQL_SCHEMA, GRAPHQL_OPTIONS, "GraphQLHandler"]
+    };
   }
-});
-var __Type = new GraphQLObjectType({
-  name: "__Type",
-  description: "The fundamental unit of any GraphQL Schema is the type. There are many kinds of types in GraphQL as represented by the `__TypeKind` enum.\n\nDepending on the kind of a type, certain fields describe information about that type. Scalar types provide no information beyond a name, description and optional `specifiedByURL`, while Enum types provide their values. Object and Interface types provide the fields they describe. Abstract types, Union and Interface, provide the Object types possible at runtime. List and NonNull types compose other types.",
-  fields: () => ({
-    kind: {
-      type: new GraphQLNonNull(__TypeKind),
-      resolve(type) {
-        if (isScalarType(type)) {
-          return TypeKind.SCALAR;
-        }
-        if (isObjectType(type)) {
-          return TypeKind.OBJECT;
-        }
-        if (isInterfaceType(type)) {
-          return TypeKind.INTERFACE;
-        }
-        if (isUnionType(type)) {
-          return TypeKind.UNION;
-        }
-        if (isEnumType(type)) {
-          return TypeKind.ENUM;
-        }
-        if (isInputObjectType(type)) {
-          return TypeKind.INPUT_OBJECT;
-        }
-        if (isListType(type)) {
-          return TypeKind.LIST;
-        }
-        if (isNonNullType(type)) {
-          return TypeKind.NON_NULL;
-        }
-        invariant(false, `Unexpected type: "${inspect(type)}".`);
-      }
-    },
-    name: {
-      type: GraphQLString,
-      resolve: (type) => ("name" in type) ? type.name : undefined
-    },
-    description: {
-      type: GraphQLString,
-      resolve: (type) => ("description" in type) ? type.description : undefined
-    },
-    specifiedByURL: {
-      type: GraphQLString,
-      resolve: (obj) => ("specifiedByURL" in obj) ? obj.specifiedByURL : undefined
-    },
-    fields: {
-      type: new GraphQLList(new GraphQLNonNull(__Field)),
-      args: {
-        includeDeprecated: {
-          type: GraphQLBoolean,
-          defaultValue: false
-        }
-      },
-      resolve(type, { includeDeprecated }) {
-        if (isObjectType(type) || isInterfaceType(type)) {
-          const fields = Object.values(type.getFields());
-          return includeDeprecated ? fields : fields.filter((field) => field.deprecationReason == null);
-        }
-      }
-    },
-    interfaces: {
-      type: new GraphQLList(new GraphQLNonNull(__Type)),
-      resolve(type) {
-        if (isObjectType(type) || isInterfaceType(type)) {
-          return type.getInterfaces();
-        }
-      }
-    },
-    possibleTypes: {
-      type: new GraphQLList(new GraphQLNonNull(__Type)),
-      resolve(type, _args, _context, { schema }) {
-        if (isAbstractType(type)) {
-          return schema.getPossibleTypes(type);
-        }
-      }
-    },
-    enumValues: {
-      type: new GraphQLList(new GraphQLNonNull(__EnumValue)),
-      args: {
-        includeDeprecated: {
-          type: GraphQLBoolean,
-          defaultValue: false
-        }
-      },
-      resolve(type, { includeDeprecated }) {
-        if (isEnumType(type)) {
-          const values = type.getValues();
-          return includeDeprecated ? values : values.filter((field) => field.deprecationReason == null);
-        }
-      }
-    },
-    inputFields: {
-      type: new GraphQLList(new GraphQLNonNull(__InputValue)),
-      args: {
-        includeDeprecated: {
-          type: GraphQLBoolean,
-          defaultValue: false
-        }
-      },
-      resolve(type, { includeDeprecated }) {
-        if (isInputObjectType(type)) {
-          const values = Object.values(type.getFields());
-          return includeDeprecated ? values : values.filter((field) => field.deprecationReason == null);
-        }
-      }
-    },
-    ofType: {
-      type: __Type,
-      resolve: (type) => ("ofType" in type) ? type.ofType : undefined
-    },
-    isOneOf: {
-      type: GraphQLBoolean,
-      resolve: (type) => {
-        if (isInputObjectType(type)) {
-          return type.isOneOf;
-        }
-      }
-    }
-  })
-});
-var __Field = new GraphQLObjectType({
-  name: "__Field",
-  description: "Object and Interface types are described by a list of Fields, each of which has a name, potentially a list of arguments, and a return type.",
-  fields: () => ({
-    name: {
-      type: new GraphQLNonNull(GraphQLString),
-      resolve: (field) => field.name
-    },
-    description: {
-      type: GraphQLString,
-      resolve: (field) => field.description
-    },
-    args: {
-      type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(__InputValue))),
-      args: {
-        includeDeprecated: {
-          type: GraphQLBoolean,
-          defaultValue: false
+  static forRootAsync(options) {
+    return {
+      module: GraphQLModule,
+      global: true,
+      imports: options.imports || [],
+      providers: [
+        {
+          provide: GRAPHQL_OPTIONS,
+          useFactory: options.useFactory,
+          inject: options.inject || []
+        },
+        {
+          provide: GRAPHQL_SCHEMA,
+          useFactory: (opts) => {
+            const resolvers = opts.resolvers || [];
+            for (const resolver of resolvers) {
+              const instance = new resolver;
+              this.schemaBuilder.addResolver(instance);
+            }
+            return this.schemaBuilder.build();
+          },
+          inject: [GRAPHQL_OPTIONS]
+        },
+        {
+          provide: "GraphQLHandler",
+          useFactory: (schema, opts) => {
+            return new GraphQLHandler(schema, opts);
+          },
+          inject: [GRAPHQL_SCHEMA, GRAPHQL_OPTIONS]
         }
-      },
-      resolve(field, { includeDeprecated }) {
-        return includeDeprecated ? field.args : field.args.filter((arg) => arg.deprecationReason == null);
-      }
-    },
-    type: {
-      type: new GraphQLNonNull(__Type),
-      resolve: (field) => field.type
-    },
-    isDeprecated: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      resolve: (field) => field.deprecationReason != null
-    },
-    deprecationReason: {
-      type: GraphQLString,
-      resolve: (field) => field.deprecationReason
-    }
-  })
-});
-var __InputValue = new GraphQLObjectType({
-  name: "__InputValue",
-  description: "Arguments provided to Fields or Directives and the input fields of an InputObject are represented as Input Values which describe their type and optionally a default value.",
-  fields: () => ({
-    name: {
-      type: new GraphQLNonNull(GraphQLString),
-      resolve: (inputValue) => inputValue.name
-    },
-    description: {
-      type: GraphQLString,
-      resolve: (inputValue) => inputValue.description
-    },
-    type: {
-      type: new GraphQLNonNull(__Type),
-      resolve: (inputValue) => inputValue.type
-    },
-    defaultValue: {
-      type: GraphQLString,
-      description: "A GraphQL-formatted string representing the default value for this input value.",
-      resolve(inputValue) {
-        const { type, defaultValue } = inputValue;
-        const valueAST = astFromValue(defaultValue, type);
-        return valueAST ? print(valueAST) : null;
-      }
-    },
-    isDeprecated: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      resolve: (field) => field.deprecationReason != null
-    },
-    deprecationReason: {
-      type: GraphQLString,
-      resolve: (obj) => obj.deprecationReason
-    }
-  })
-});
-var __EnumValue = new GraphQLObjectType({
-  name: "__EnumValue",
-  description: "One possible value for a given Enum. Enum values are unique values, not a placeholder for a string or numeric value. However an Enum value is returned in a JSON response as a string.",
-  fields: () => ({
-    name: {
-      type: new GraphQLNonNull(GraphQLString),
-      resolve: (enumValue) => enumValue.name
-    },
-    description: {
-      type: GraphQLString,
-      resolve: (enumValue) => enumValue.description
-    },
-    isDeprecated: {
-      type: new GraphQLNonNull(GraphQLBoolean),
-      resolve: (enumValue) => enumValue.deprecationReason != null
-    },
-    deprecationReason: {
-      type: GraphQLString,
-      resolve: (enumValue) => enumValue.deprecationReason
-    }
-  })
-});
-var TypeKind;
-(function(TypeKind) {
-  TypeKind["SCALAR"] = "SCALAR";
-  TypeKind["OBJECT"] = "OBJECT";
-  TypeKind["INTERFACE"] = "INTERFACE";
-  TypeKind["UNION"] = "UNION";
-  TypeKind["ENUM"] = "ENUM";
-  TypeKind["INPUT_OBJECT"] = "INPUT_OBJECT";
-  TypeKind["LIST"] = "LIST";
-  TypeKind["NON_NULL"] = "NON_NULL";
-})(TypeKind || (TypeKind = {}));
-var __TypeKind = new GraphQLEnumType({
-  name: "__TypeKind",
-  description: "An enum describing what kind of type a given `__Type` is.",
-  values: {
-    SCALAR: {
-      value: TypeKind.SCALAR,
-      description: "Indicates this type is a scalar."
-    },
-    OBJECT: {
-      value: TypeKind.OBJECT,
-      description: "Indicates this type is an object. `fields` and `interfaces` are valid fields."
-    },
-    INTERFACE: {
-      value: TypeKind.INTERFACE,
-      description: "Indicates this type is an interface. `fields`, `interfaces`, and `possibleTypes` are valid fields."
-    },
-    UNION: {
-      value: TypeKind.UNION,
-      description: "Indicates this type is a union. `possibleTypes` is a valid field."
-    },
-    ENUM: {
-      value: TypeKind.ENUM,
-      description: "Indicates this type is an enum. `enumValues` is a valid field."
-    },
-    INPUT_OBJECT: {
-      value: TypeKind.INPUT_OBJECT,
-      description: "Indicates this type is an input object. `inputFields` is a valid field."
-    },
-    LIST: {
-      value: TypeKind.LIST,
-      description: "Indicates this type is a list. `ofType` is a valid field."
-    },
-    NON_NULL: {
-      value: TypeKind.NON_NULL,
-      description: "Indicates this type is a non-null. `ofType` is a valid field."
-    }
+      ],
+      exports: [GRAPHQL_SCHEMA, GRAPHQL_OPTIONS, "GraphQLHandler"]
+    };
   }
-});
-var SchemaMetaFieldDef = {
-  name: "__schema",
-  type: new GraphQLNonNull(__Schema),
-  description: "Access the current type schema of this server.",
-  args: [],
-  resolve: (_source, _args, _context, { schema }) => schema,
-  deprecationReason: undefined,
-  extensions: Object.create(null),
-  astNode: undefined
-};
-var TypeMetaFieldDef = {
-  name: "__type",
-  type: __Type,
-  description: "Request the type information of a single type.",
-  args: [
-    {
-      name: "name",
-      description: undefined,
-      type: new GraphQLNonNull(GraphQLString),
-      defaultValue: undefined,
-      deprecationReason: undefined,
-      extensions: Object.create(null),
-      astNode: undefined
-    }
-  ],
-  resolve: (_source, { name }, _context, { schema }) => schema.getType(name),
-  deprecationReason: undefined,
-  extensions: Object.create(null),
-  astNode: undefined
-};
-var TypeNameMetaFieldDef = {
-  name: "__typename",
-  type: new GraphQLNonNull(GraphQLString),
-  description: "The name of the current Object type at runtime.",
-  args: [],
-  resolve: (_source, _args, _context, { parentType }) => parentType.name,
-  deprecationReason: undefined,
-  extensions: Object.create(null),
-  astNode: undefined
-};
-var introspectionTypes = Object.freeze([
-  __Schema,
-  __Directive,
-  __DirectiveLocation,
-  __Type,
-  __Field,
-  __InputValue,
-  __EnumValue,
-  __TypeKind
-]);
-function isIntrospectionType(type) {
-  return introspectionTypes.some(({ name }) => type.name === name);
 }
 
-// ../../node_modules/graphql/type/schema.mjs
-class GraphQLSchema {
-  constructor(config) {
-    var _config$extensionASTN, _config$directives;
-    this.__validationErrors = config.assumeValid === true ? [] : undefined;
-    isObjectLike(config) || devAssert(false, "Must provide configuration object.");
-    !config.types || Array.isArray(config.types) || devAssert(false, `"types" must be Array if provided but got: ${inspect(config.types)}.`);
-    !config.directives || Array.isArray(config.directives) || devAssert(false, '"directives" must be Array if provided but got: ' + `${inspect(config.directives)}.`);
-    this.description = config.description;
-    this.extensions = toObjMap(config.extensions);
-    this.astNode = config.astNode;
-    this.extensionASTNodes = (_config$extensionASTN = config.extensionASTNodes) !== null && _config$extensionASTN !== undefined ? _config$extensionASTN : [];
-    this._queryType = config.query;
-    this._mutationType = config.mutation;
-    this._subscriptionType = config.subscription;
-    this._directives = (_config$directives = config.directives) !== null && _config$directives !== undefined ? _config$directives : specifiedDirectives;
-    const allReferencedTypes = new Set(config.types);
-    if (config.types != null) {
-      for (const type of config.types) {
-        allReferencedTypes.delete(type);
-        collectReferencedTypes(type, allReferencedTypes);
-      }
-    }
-    if (this._queryType != null) {
-      collectReferencedTypes(this._queryType, allReferencedTypes);
+class GraphQLHandler {
+  schema;
+  options;
+  constructor(schema, options) {
+    this.schema = schema;
+    this.options = options;
+  }
+  createLoaderContext() {
+    const ctx = new DataLoaderContext;
+    const loaders = this.options.loaders || {};
+    for (const [name, factory] of Object.entries(loaders)) {
+      ctx.registerLoader(name, factory);
     }
-    if (this._mutationType != null) {
-      collectReferencedTypes(this._mutationType, allReferencedTypes);
+    return ctx;
+  }
+  async handle(request) {
+    const url = new URL(request.url);
+    const path = this.options.path || "/graphql";
+    if (url.pathname !== path) {
+      return new Response("Not Found", { status: 404 });
     }
-    if (this._subscriptionType != null) {
-      collectReferencedTypes(this._subscriptionType, allReferencedTypes);
+    if (request.method === "GET" && this.options.playground) {
+      return this.servePlayground();
     }
-    for (const directive of this._directives) {
-      if (isDirective(directive)) {
-        for (const arg of directive.args) {
-          collectReferencedTypes(arg.type, allReferencedTypes);
-        }
-      }
+    if (request.method !== "POST") {
+      return new Response("Method Not Allowed", { status: 405 });
     }
-    collectReferencedTypes(__Schema, allReferencedTypes);
-    this._typeMap = Object.create(null);
-    this._subTypeMap = Object.create(null);
-    this._implementationsMap = Object.create(null);
-    for (const namedType of allReferencedTypes) {
-      if (namedType == null) {
-        continue;
-      }
-      const typeName = namedType.name;
-      typeName || devAssert(false, "One of the provided types for building the Schema is missing a name.");
-      if (this._typeMap[typeName] !== undefined) {
-        throw new Error(`Schema must contain uniquely named types but contains multiple types named "${typeName}".`);
+    try {
+      const body = await request.json();
+      const { query, variables, operationName } = body;
+      const loaderContext = this.createLoaderContext();
+      const userContext = this.options.context ? await this.options.context({ request }) : {};
+      const context = {
+        request,
+        loaders: loaderContext,
+        ...userContext
+      };
+      const document = parse(query);
+      const validationErrors = validate(this.schema, document);
+      if (validationErrors.length > 0) {
+        return new Response(JSON.stringify({
+          errors: validationErrors.map((e) => this.formatError(e))
+        }), {
+          status: 400,
+          headers: { "Content-Type": "application/json" }
+        });
       }
-      this._typeMap[typeName] = namedType;
-      if (isInterfaceType(namedType)) {
-        for (const iface of namedType.getInterfaces()) {
-          if (isInterfaceType(iface)) {
-            let implementations = this._implementationsMap[iface.name];
-            if (implementations === undefined) {
-              implementations = this._implementationsMap[iface.name] = {
-                objects: [],
-                interfaces: []
-              };
-            }
-            implementations.interfaces.push(namedType);
-          }
-        }
-      } else if (isObjectType(namedType)) {
-        for (const iface of namedType.getInterfaces()) {
-          if (isInterfaceType(iface)) {
-            let implementations = this._implementationsMap[iface.name];
-            if (implementations === undefined) {
-              implementations = this._implementationsMap[iface.name] = {
-                objects: [],
-                interfaces: []
-              };
-            }
-            implementations.objects.push(namedType);
-          }
-        }
+      const result = await execute({
+        schema: this.schema,
+        document,
+        contextValue: context,
+        variableValues: variables,
+        operationName
+      });
+      if (result.errors) {
+        result.errors = result.errors.map((e) => this.formatError(e));
       }
+      return new Response(JSON.stringify(result), {
+        headers: { "Content-Type": "application/json" }
+      });
+    } catch (error) {
+      return new Response(JSON.stringify({
+        errors: [this.formatError(error)]
+      }), {
+        status: 500,
+        headers: { "Content-Type": "application/json" }
+      });
     }
   }
-  get [Symbol.toStringTag]() {
-    return "GraphQLSchema";
-  }
-  getQueryType() {
-    return this._queryType;
-  }
-  getMutationType() {
-    return this._mutationType;
-  }
-  getSubscriptionType() {
-    return this._subscriptionType;
-  }
-  getRootType(operation) {
-    switch (operation) {
-      case OperationTypeNode.QUERY:
-        return this.getQueryType();
-      case OperationTypeNode.MUTATION:
-        return this.getMutationType();
-      case OperationTypeNode.SUBSCRIPTION:
-        return this.getSubscriptionType();
-    }
-  }
-  getTypeMap() {
-    return this._typeMap;
-  }
-  getType(name) {
-    return this.getTypeMap()[name];
-  }
-  getPossibleTypes(abstractType) {
-    return isUnionType(abstractType) ? abstractType.getTypes() : this.getImplementations(abstractType).objects;
-  }
-  getImplementations(interfaceType) {
-    const implementations = this._implementationsMap[interfaceType.name];
-    return implementations !== null && implementations !== undefined ? implementations : {
-      objects: [],
-      interfaces: []
-    };
-  }
-  isSubType(abstractType, maybeSubType) {
-    let map = this._subTypeMap[abstractType.name];
-    if (map === undefined) {
-      map = Object.create(null);
-      if (isUnionType(abstractType)) {
-        for (const type of abstractType.getTypes()) {
-          map[type.name] = true;
-        }
-      } else {
-        const implementations = this.getImplementations(abstractType);
-        for (const type of implementations.objects) {
-          map[type.name] = true;
-        }
-        for (const type of implementations.interfaces) {
-          map[type.name] = true;
-        }
-      }
-      this._subTypeMap[abstractType.name] = map;
+  formatError(error) {
+    if (this.options.formatError) {
+      return this.options.formatError(error);
     }
-    return map[maybeSubType.name] !== undefined;
-  }
-  getDirectives() {
-    return this._directives;
-  }
-  getDirective(name) {
-    return this.getDirectives().find((directive) => directive.name === name);
-  }
-  toConfig() {
     return {
-      description: this.description,
-      query: this.getQueryType(),
-      mutation: this.getMutationType(),
-      subscription: this.getSubscriptionType(),
-      types: Object.values(this.getTypeMap()),
-      directives: this.getDirectives(),
-      extensions: this.extensions,
-      astNode: this.astNode,
-      extensionASTNodes: this.extensionASTNodes,
-      assumeValid: this.__validationErrors !== undefined
+      message: error.message,
+      locations: error.locations,
+      path: error.path
     };
   }
-}
-function collectReferencedTypes(type, typeSet) {
-  const namedType = getNamedType(type);
-  if (!typeSet.has(namedType)) {
-    typeSet.add(namedType);
-    if (isUnionType(namedType)) {
-      for (const memberType of namedType.getTypes()) {
-        collectReferencedTypes(memberType, typeSet);
-      }
-    } else if (isObjectType(namedType) || isInterfaceType(namedType)) {
-      for (const interfaceType of namedType.getInterfaces()) {
-        collectReferencedTypes(interfaceType, typeSet);
-      }
-      for (const field of Object.values(namedType.getFields())) {
-        collectReferencedTypes(field.type, typeSet);
-        for (const arg of field.args) {
-          collectReferencedTypes(arg.type, typeSet);
-        }
-      }
-    } else if (isInputObjectType(namedType)) {
-      for (const field of Object.values(namedType.getFields())) {
-        collectReferencedTypes(field.type, typeSet);
-      }
-    }
-  }
-  return typeSet;
-}
-// ../../node_modules/graphql/utilities/printSchema.mjs
-function printSchema(schema) {
-  return printFilteredSchema(schema, (n) => !isSpecifiedDirective(n), isDefinedType);
-}
-function isDefinedType(type) {
-  return !isSpecifiedScalarType(type) && !isIntrospectionType(type);
-}
-function printFilteredSchema(schema, directiveFilter, typeFilter) {
-  const directives = schema.getDirectives().filter(directiveFilter);
-  const types = Object.values(schema.getTypeMap()).filter(typeFilter);
-  return [
-    printSchemaDefinition(schema),
-    ...directives.map((directive) => printDirective(directive)),
-    ...types.map((type) => printType(type))
-  ].filter(Boolean).join(`
-
-`);
-}
-function printSchemaDefinition(schema) {
-  if (schema.description == null && isSchemaOfCommonNames(schema)) {
-    return;
-  }
-  const operationTypes = [];
-  const queryType = schema.getQueryType();
-  if (queryType) {
-    operationTypes.push(`  query: ${queryType.name}`);
-  }
-  const mutationType = schema.getMutationType();
-  if (mutationType) {
-    operationTypes.push(`  mutation: ${mutationType.name}`);
-  }
-  const subscriptionType = schema.getSubscriptionType();
-  if (subscriptionType) {
-    operationTypes.push(`  subscription: ${subscriptionType.name}`);
-  }
-  return printDescription(schema) + `schema {
-${operationTypes.join(`
-`)}
-}`;
-}
-function isSchemaOfCommonNames(schema) {
-  const queryType = schema.getQueryType();
-  if (queryType && queryType.name !== "Query") {
-    return false;
-  }
-  const mutationType = schema.getMutationType();
-  if (mutationType && mutationType.name !== "Mutation") {
-    return false;
-  }
-  const subscriptionType = schema.getSubscriptionType();
-  if (subscriptionType && subscriptionType.name !== "Subscription") {
-    return false;
-  }
-  return true;
-}
-function printType(type) {
-  if (isScalarType(type)) {
-    return printScalar(type);
-  }
-  if (isObjectType(type)) {
-    return printObject(type);
-  }
-  if (isInterfaceType(type)) {
-    return printInterface(type);
-  }
-  if (isUnionType(type)) {
-    return printUnion(type);
-  }
-  if (isEnumType(type)) {
-    return printEnum(type);
-  }
-  if (isInputObjectType(type)) {
-    return printInputObject(type);
-  }
-  invariant(false, "Unexpected type: " + inspect(type));
-}
-function printScalar(type) {
-  return printDescription(type) + `scalar ${type.name}` + printSpecifiedByURL(type);
-}
-function printImplementedInterfaces(type) {
-  const interfaces = type.getInterfaces();
-  return interfaces.length ? " implements " + interfaces.map((i) => i.name).join(" & ") : "";
-}
-function printObject(type) {
-  return printDescription(type) + `type ${type.name}` + printImplementedInterfaces(type) + printFields(type);
-}
-function printInterface(type) {
-  return printDescription(type) + `interface ${type.name}` + printImplementedInterfaces(type) + printFields(type);
-}
-function printUnion(type) {
-  const types = type.getTypes();
-  const possibleTypes = types.length ? " = " + types.join(" | ") : "";
-  return printDescription(type) + "union " + type.name + possibleTypes;
-}
-function printEnum(type) {
-  const values = type.getValues().map((value, i) => printDescription(value, "  ", !i) + "  " + value.name + printDeprecated(value.deprecationReason));
-  return printDescription(type) + `enum ${type.name}` + printBlock(values);
-}
-function printInputObject(type) {
-  const fields = Object.values(type.getFields()).map((f, i) => printDescription(f, "  ", !i) + "  " + printInputValue(f));
-  return printDescription(type) + `input ${type.name}` + (type.isOneOf ? " @oneOf" : "") + printBlock(fields);
-}
-function printFields(type) {
-  const fields = Object.values(type.getFields()).map((f, i) => printDescription(f, "  ", !i) + "  " + f.name + printArgs(f.args, "  ") + ": " + String(f.type) + printDeprecated(f.deprecationReason));
-  return printBlock(fields);
-}
-function printBlock(items) {
-  return items.length !== 0 ? ` {
-` + items.join(`
-`) + `
-}` : "";
-}
-function printArgs(args, indentation = "") {
-  if (args.length === 0) {
-    return "";
-  }
-  if (args.every((arg) => !arg.description)) {
-    return "(" + args.map(printInputValue).join(", ") + ")";
-  }
-  return `(
-` + args.map((arg, i) => printDescription(arg, "  " + indentation, !i) + "  " + indentation + printInputValue(arg)).join(`
-`) + `
-` + indentation + ")";
-}
-function printInputValue(arg) {
-  const defaultAST = astFromValue(arg.defaultValue, arg.type);
-  let argDecl = arg.name + ": " + String(arg.type);
-  if (defaultAST) {
-    argDecl += ` = ${print(defaultAST)}`;
-  }
-  return argDecl + printDeprecated(arg.deprecationReason);
-}
-function printDirective(directive) {
-  return printDescription(directive) + "directive @" + directive.name + printArgs(directive.args) + (directive.isRepeatable ? " repeatable" : "") + " on " + directive.locations.join(" | ");
-}
-function printDeprecated(reason) {
-  if (reason == null) {
-    return "";
-  }
-  if (reason !== DEFAULT_DEPRECATION_REASON) {
-    const astValue = print({
-      kind: Kind.STRING,
-      value: reason
+  servePlayground() {
+    const html = `
+<!DOCTYPE html>
+<html>
+<head>
+  <title>GraphQL Playground</title>
+  <link rel="stylesheet" href="https://cdn.jsdelivr.net/npm/graphiql@3/graphiql.min.css" />
+</head>
+<body style="margin: 0;">
+  <div id="graphiql" style="height: 100vh;"></div>
+  <script crossorigin src="https://unpkg.com/react@18/umd/react.production.min.js"></script>
+  <script crossorigin src="https://unpkg.com/react-dom@18/umd/react-dom.production.min.js"></script>
+  <script crossorigin src="https://cdn.jsdelivr.net/npm/graphiql@3/graphiql.min.js"></script>
+  <script>
+    const fetcher = GraphiQL.createFetcher({ url: '${this.options.path || "/graphql"}' });
+    ReactDOM.createRoot(document.getElementById('graphiql')).render(
+      React.createElement(GraphiQL, { fetcher })
+    );
+  </script>
+</body>
+</html>`;
+    return new Response(html, {
+      headers: { "Content-Type": "text/html" }
     });
-    return ` @deprecated(reason: ${astValue})`;
-  }
-  return " @deprecated";
-}
-function printSpecifiedByURL(scalar) {
-  if (scalar.specifiedByURL == null) {
-    return "";
-  }
-  const astValue = print({
-    kind: Kind.STRING,
-    value: scalar.specifiedByURL
-  });
-  return ` @specifiedBy(url: ${astValue})`;
-}
-function printDescription(def, indentation = "", firstInBlock = true) {
-  const { description } = def;
-  if (description == null) {
-    return "";
   }
-  const blockString = print({
-    kind: Kind.STRING,
-    value: description,
-    block: isPrintableAsBlockString(description)
-  });
-  const prefix = indentation && !firstInBlock ? `
-` + indentation : indentation;
-  return prefix + blockString.replace(/\n/g, `
-` + indentation) + `
-`;
 }
+// ../graphql/src/subscriptions/websocket-server.ts
+import { parse as parse2, validate as validate2, subscribe } from "graphql";
+// ../graphql/src/scalars.ts
+var ID = Symbol("ID");
+var Int = Symbol("Int");
+var Float = Symbol("Float");
 // src/schema/federation-schema-builder.ts
-import { SchemaBuilder } from "@galaxy-stack/orbit-graphql";
 class FederationSchemaBuilder extends SchemaBuilder {
   entityTypes = new Map;
   referenceResolvers = new Map;
@@ -3254,13 +646,13 @@ class FederationSchemaBuilder extends SchemaBuilder {
     const queryType = schema.getQueryType();
     const mutationType = schema.getMutationType();
     const subscriptionType = schema.getSubscriptionType();
-    const _Any = GraphQLString;
+    const _Any = GraphQLString2;
     let federatedSchemaRef;
-    const _Service = new GraphQLObjectType({
+    const _Service = new GraphQLObjectType2({
       name: "_Service",
       fields: {
         sdl: {
-          type: GraphQLString,
+          type: GraphQLString2,
           resolve: () => this.generateFederatedSDL(federatedSchemaRef ?? schema)
         }
       }
@@ -3290,15 +682,15 @@ class FederationSchemaBuilder extends SchemaBuilder {
       }
     }
     federatedQueryFields["_service"] = {
-      type: new GraphQLNonNull(_Service),
+      type: new GraphQLNonNull2(_Service),
       resolve: () => ({})
     };
     if (_Entity && entities.length > 0) {
       federatedQueryFields["_entities"] = {
-        type: new GraphQLNonNull(new GraphQLList(_Entity)),
+        type: new GraphQLNonNull2(new GraphQLList2(_Entity)),
         args: {
           representations: {
-            type: new GraphQLNonNull(new GraphQLList(new GraphQLNonNull(GraphQLString)))
+            type: new GraphQLNonNull2(new GraphQLList2(new GraphQLNonNull2(GraphQLString2)))
           }
         },
         resolve: async (_, { representations }) => {
@@ -3318,11 +710,11 @@ class FederationSchemaBuilder extends SchemaBuilder {
         }
       };
     }
-    const federatedQuery = new GraphQLObjectType({
+    const federatedQuery = new GraphQLObjectType2({
       name: "Query",
       fields: federatedQueryFields
     });
-    federatedSchemaRef = new GraphQLSchema({
+    federatedSchemaRef = new GraphQLSchema4({
       query: federatedQuery,
       mutation: mutationType || undefined,
       subscription: subscriptionType || undefined