@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@graphql-tools/utils/esm/getArgumentValues.js

@@ -0,0 +1,61 @@
+import { inspect } from "../../../cross-inspect/esm/index.js";
+import { createGraphQLError } from "./errors.js";
+import { hasOwnProperty } from "./jsutils.js";
+import { isNonNullType } from "../../../graphql/type/definition.js";
+import { Kind } from "../../../graphql/language/kinds.js";
+import { valueFromAST } from "../../../graphql/utilities/valueFromAST.js";
+import { print } from "../../../graphql/language/printer.js";
+function getArgumentValues(def, node, variableValues = {}) {
+  const coercedValues = {};
+  const argumentNodes = node.arguments ?? [];
+  const argNodeMap = argumentNodes.reduce((prev, arg) => ({
+    ...prev,
+    [arg.name.value]: arg
+  }), {});
+  for (const { name, type: argType, defaultValue } of def.args) {
+    const argumentNode = argNodeMap[name];
+    if (!argumentNode) {
+      if (defaultValue !== void 0) {
+        coercedValues[name] = defaultValue;
+      } else if (isNonNullType(argType)) {
+        throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" was not provided.`, {
+          nodes: [node]
+        });
+      }
+      continue;
+    }
+    const valueNode = argumentNode.value;
+    let isNull = valueNode.kind === Kind.NULL;
+    if (valueNode.kind === Kind.VARIABLE) {
+      const variableName = valueNode.name.value;
+      if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {
+        if (defaultValue !== void 0) {
+          coercedValues[name] = defaultValue;
+        } else if (isNonNullType(argType)) {
+          throw createGraphQLError(`Argument "${name}" of required type "${inspect(argType)}" was provided the variable "$${variableName}" which was not provided a runtime value.`, {
+            nodes: [valueNode]
+          });
+        }
+        continue;
+      }
+      isNull = variableValues[variableName] == null;
+    }
+    if (isNull && isNonNullType(argType)) {
+      throw createGraphQLError(`Argument "${name}" of non-null type "${inspect(argType)}" must not be null.`, {
+        nodes: [valueNode]
+      });
+    }
+    const coercedValue = valueFromAST(valueNode, argType, variableValues);
+    if (coercedValue === void 0) {
+      throw createGraphQLError(`Argument "${name}" has invalid value ${print(valueNode)}.`, {
+        nodes: [valueNode]
+      });
+    }
+    coercedValues[name] = coercedValue;
+  }
+  return coercedValues;
+}
+export {
+  getArgumentValues
+};
+//# sourceMappingURL=getArgumentValues.js.map

package/dist/node_modules/@graphql-tools/utils/esm/getArgumentValues.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getArgumentValues.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/getArgumentValues.js"],"sourcesContent":["import { inspect } from 'cross-inspect';\nimport { isNonNullType, Kind, print, valueFromAST, } from 'graphql';\nimport { createGraphQLError } from './errors.js';\nimport { hasOwnProperty } from './jsutils.js';\n/**\n * Prepares an object map of argument values given a list of argument\n * definitions and list of argument AST nodes.\n *\n * Note: The returned value is a plain Object with a prototype, since it is\n * exposed to user code. Care should be taken to not pull values from the\n * Object prototype.\n */\nexport function getArgumentValues(def, node, variableValues = {}) {\n    const coercedValues = {};\n    const argumentNodes = node.arguments ?? [];\n    const argNodeMap = argumentNodes.reduce((prev, arg) => ({\n        ...prev,\n        [arg.name.value]: arg,\n    }), {});\n    for (const { name, type: argType, defaultValue } of def.args) {\n        const argumentNode = argNodeMap[name];\n        if (!argumentNode) {\n            if (defaultValue !== undefined) {\n                coercedValues[name] = defaultValue;\n            }\n            else if (isNonNullType(argType)) {\n                throw createGraphQLError(`Argument \"${name}\" of required type \"${inspect(argType)}\" ` + 'was not provided.', {\n                    nodes: [node],\n                });\n            }\n            continue;\n        }\n        const valueNode = argumentNode.value;\n        let isNull = valueNode.kind === Kind.NULL;\n        if (valueNode.kind === Kind.VARIABLE) {\n            const variableName = valueNode.name.value;\n            if (variableValues == null || !hasOwnProperty(variableValues, variableName)) {\n                if (defaultValue !== undefined) {\n                    coercedValues[name] = defaultValue;\n                }\n                else if (isNonNullType(argType)) {\n                    throw createGraphQLError(`Argument \"${name}\" of required type \"${inspect(argType)}\" ` +\n                        `was provided the variable \"$${variableName}\" which was not provided a runtime value.`, {\n                        nodes: [valueNode],\n                    });\n                }\n                continue;\n            }\n            isNull = variableValues[variableName] == null;\n        }\n        if (isNull && isNonNullType(argType)) {\n            throw createGraphQLError(`Argument \"${name}\" of non-null type \"${inspect(argType)}\" ` + 'must not be null.', {\n                nodes: [valueNode],\n            });\n        }\n        const coercedValue = valueFromAST(valueNode, argType, variableValues);\n        if (coercedValue === undefined) {\n            // Note: ValuesOfCorrectTypeRule validation should catch this before\n            // execution. This is a runtime check to ensure execution does not\n            // continue with an invalid argument value.\n            throw createGraphQLError(`Argument \"${name}\" has invalid value ${print(valueNode)}.`, {\n                nodes: [valueNode],\n            });\n        }\n        coercedValues[name] = coercedValue;\n    }\n    return coercedValues;\n}\n"],"names":[],"mappings":";;;;;;;AAYO,SAAS,kBAAkB,KAAK,MAAM,iBAAiB,CAAA,GAAI;AAC9D,QAAM,gBAAgB,CAAA;AACtB,QAAM,gBAAgB,KAAK,aAAa,CAAA;AACxC,QAAM,aAAa,cAAc,OAAO,CAAC,MAAM,SAAS;AAAA,IACpD,GAAG;AAAA,IACH,CAAC,IAAI,KAAK,KAAK,GAAG;AAAA,EAC1B,IAAQ,CAAA,CAAE;AACN,aAAW,EAAE,MAAM,MAAM,SAAS,aAAY,KAAM,IAAI,MAAM;AAC1D,UAAM,eAAe,WAAW,IAAI;AACpC,QAAI,CAAC,cAAc;AACf,UAAI,iBAAiB,QAAW;AAC5B,sBAAc,IAAI,IAAI;AAAA,MAC1B,WACS,cAAc,OAAO,GAAG;AAC7B,cAAM,mBAAmB,aAAa,IAAI,uBAAuB,QAAQ,OAAO,CAAC,uBAA4B;AAAA,UACzG,OAAO,CAAC,IAAI;AAAA,QAChC,CAAiB;AAAA,MACL;AACA;AAAA,IACJ;AACA,UAAM,YAAY,aAAa;AAC/B,QAAI,SAAS,UAAU,SAAS,KAAK;AACrC,QAAI,UAAU,SAAS,KAAK,UAAU;AAClC,YAAM,eAAe,UAAU,KAAK;AACpC,UAAI,kBAAkB,QAAQ,CAAC,eAAe,gBAAgB,YAAY,GAAG;AACzE,YAAI,iBAAiB,QAAW;AAC5B,wBAAc,IAAI,IAAI;AAAA,QAC1B,WACS,cAAc,OAAO,GAAG;AAC7B,gBAAM,mBAAmB,aAAa,IAAI,uBAAuB,QAAQ,OAAO,CAAC,iCAC9C,YAAY,6CAA6C;AAAA,YACxF,OAAO,CAAC,SAAS;AAAA,UACzC,CAAqB;AAAA,QACL;AACA;AAAA,MACJ;AACA,eAAS,eAAe,YAAY,KAAK;AAAA,IAC7C;AACA,QAAI,UAAU,cAAc,OAAO,GAAG;AAClC,YAAM,mBAAmB,aAAa,IAAI,uBAAuB,QAAQ,OAAO,CAAC,uBAA4B;AAAA,QACzG,OAAO,CAAC,SAAS;AAAA,MACjC,CAAa;AAAA,IACL;AACA,UAAM,eAAe,aAAa,WAAW,SAAS,cAAc;AACpE,QAAI,iBAAiB,QAAW;AAI5B,YAAM,mBAAmB,aAAa,IAAI,uBAAuB,MAAM,SAAS,CAAC,KAAK;AAAA,QAClF,OAAO,CAAC,SAAS;AAAA,MACjC,CAAa;AAAA,IACL;AACA,kBAAc,IAAI,IAAI;AAAA,EAC1B;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/getDirectiveExtensions.js

@@ -0,0 +1,76 @@
+import { memoize1 } from "./memoize.js";
+import { valueFromASTUntyped } from "../../../graphql/utilities/valueFromASTUntyped.js";
+function getDirectiveExtensions(directableObj, schema, pathToDirectivesInExtensions = ["directives"]) {
+  const directiveExtensions = {};
+  if (directableObj.extensions) {
+    let directivesInExtensions = directableObj.extensions;
+    for (const pathSegment of pathToDirectivesInExtensions) {
+      directivesInExtensions = directivesInExtensions?.[pathSegment];
+    }
+    if (directivesInExtensions != null) {
+      for (const directiveNameProp in directivesInExtensions) {
+        const directiveObjs = directivesInExtensions[directiveNameProp];
+        const directiveName = directiveNameProp;
+        if (Array.isArray(directiveObjs)) {
+          for (const directiveObj of directiveObjs) {
+            let existingDirectiveExtensions = directiveExtensions[directiveName];
+            if (!existingDirectiveExtensions) {
+              existingDirectiveExtensions = [];
+              directiveExtensions[directiveName] = existingDirectiveExtensions;
+            }
+            existingDirectiveExtensions.push(directiveObj);
+          }
+        } else {
+          let existingDirectiveExtensions = directiveExtensions[directiveName];
+          if (!existingDirectiveExtensions) {
+            existingDirectiveExtensions = [];
+            directiveExtensions[directiveName] = existingDirectiveExtensions;
+          }
+          existingDirectiveExtensions.push(directiveObjs);
+        }
+      }
+    }
+  }
+  const memoizedStringify = memoize1((obj) => JSON.stringify(obj));
+  const astNodes = [];
+  if (directableObj.astNode) {
+    astNodes.push(directableObj.astNode);
+  }
+  if (directableObj.extensionASTNodes) {
+    astNodes.push(...directableObj.extensionASTNodes);
+  }
+  for (const astNode of astNodes) {
+    if (astNode.directives?.length) {
+      for (const directive of astNode.directives) {
+        const directiveName = directive.name.value;
+        let existingDirectiveExtensions = directiveExtensions[directiveName];
+        if (!existingDirectiveExtensions) {
+          existingDirectiveExtensions = [];
+          directiveExtensions[directiveName] = existingDirectiveExtensions;
+        }
+        let value = {};
+        if (directive.arguments) {
+          for (const argNode of directive.arguments) {
+            const argName = argNode.name.value;
+            if (value[argName] == null) ;
+            if (value[argName] == null) {
+              value[argName] = valueFromASTUntyped(argNode.value);
+            }
+          }
+        }
+        if (astNodes.length > 0 && existingDirectiveExtensions.length > 0) {
+          const valStr = memoizedStringify(value);
+          if (existingDirectiveExtensions.some((val) => memoizedStringify(val) === valStr)) {
+            continue;
+          }
+        }
+        existingDirectiveExtensions.push(value);
+      }
+    }
+  }
+  return directiveExtensions;
+}
+export {
+  getDirectiveExtensions
+};
+//# sourceMappingURL=getDirectiveExtensions.js.map

package/dist/node_modules/@graphql-tools/utils/esm/getDirectiveExtensions.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getDirectiveExtensions.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/getDirectiveExtensions.js"],"sourcesContent":["import { valueFromAST, valueFromASTUntyped } from 'graphql';\nimport { getArgumentValues } from './getArgumentValues.js';\nimport { memoize1 } from './memoize.js';\nexport function getDirectiveExtensions(directableObj, schema, pathToDirectivesInExtensions = ['directives']) {\n    const directiveExtensions = {};\n    if (directableObj.extensions) {\n        let directivesInExtensions = directableObj.extensions;\n        for (const pathSegment of pathToDirectivesInExtensions) {\n            directivesInExtensions = directivesInExtensions?.[pathSegment];\n        }\n        if (directivesInExtensions != null) {\n            for (const directiveNameProp in directivesInExtensions) {\n                const directiveObjs = directivesInExtensions[directiveNameProp];\n                const directiveName = directiveNameProp;\n                if (Array.isArray(directiveObjs)) {\n                    for (const directiveObj of directiveObjs) {\n                        let existingDirectiveExtensions = directiveExtensions[directiveName];\n                        if (!existingDirectiveExtensions) {\n                            existingDirectiveExtensions = [];\n                            directiveExtensions[directiveName] = existingDirectiveExtensions;\n                        }\n                        existingDirectiveExtensions.push(directiveObj);\n                    }\n                }\n                else {\n                    let existingDirectiveExtensions = directiveExtensions[directiveName];\n                    if (!existingDirectiveExtensions) {\n                        existingDirectiveExtensions = [];\n                        directiveExtensions[directiveName] = existingDirectiveExtensions;\n                    }\n                    existingDirectiveExtensions.push(directiveObjs);\n                }\n            }\n        }\n    }\n    const memoizedStringify = memoize1(obj => JSON.stringify(obj));\n    const astNodes = [];\n    if (directableObj.astNode) {\n        astNodes.push(directableObj.astNode);\n    }\n    if (directableObj.extensionASTNodes) {\n        astNodes.push(...directableObj.extensionASTNodes);\n    }\n    for (const astNode of astNodes) {\n        if (astNode.directives?.length) {\n            for (const directive of astNode.directives) {\n                const directiveName = directive.name.value;\n                let existingDirectiveExtensions = directiveExtensions[directiveName];\n                if (!existingDirectiveExtensions) {\n                    existingDirectiveExtensions = [];\n                    directiveExtensions[directiveName] = existingDirectiveExtensions;\n                }\n                const directiveInSchema = schema?.getDirective(directiveName);\n                let value = {};\n                if (directiveInSchema) {\n                    value = getArgumentValues(directiveInSchema, directive);\n                }\n                if (directive.arguments) {\n                    for (const argNode of directive.arguments) {\n                        const argName = argNode.name.value;\n                        if (value[argName] == null) {\n                            const argInDirective = directiveInSchema?.args.find(arg => arg.name === argName);\n                            if (argInDirective) {\n                                value[argName] = valueFromAST(argNode.value, argInDirective.type);\n                            }\n                        }\n                        if (value[argName] == null) {\n                            value[argName] = valueFromASTUntyped(argNode.value);\n                        }\n                    }\n                }\n                if (astNodes.length > 0 && existingDirectiveExtensions.length > 0) {\n                    const valStr = memoizedStringify(value);\n                    if (existingDirectiveExtensions.some(val => memoizedStringify(val) === valStr)) {\n                        continue;\n                    }\n                }\n                existingDirectiveExtensions.push(value);\n            }\n        }\n    }\n    return directiveExtensions;\n}\n"],"names":[],"mappings":";;AAGO,SAAS,uBAAuB,eAAe,QAAQ,+BAA+B,CAAC,YAAY,GAAG;AACzG,QAAM,sBAAsB,CAAA;AAC5B,MAAI,cAAc,YAAY;AAC1B,QAAI,yBAAyB,cAAc;AAC3C,eAAW,eAAe,8BAA8B;AACpD,+BAAyB,yBAAyB,WAAW;AAAA,IACjE;AACA,QAAI,0BAA0B,MAAM;AAChC,iBAAW,qBAAqB,wBAAwB;AACpD,cAAM,gBAAgB,uBAAuB,iBAAiB;AAC9D,cAAM,gBAAgB;AACtB,YAAI,MAAM,QAAQ,aAAa,GAAG;AAC9B,qBAAW,gBAAgB,eAAe;AACtC,gBAAI,8BAA8B,oBAAoB,aAAa;AACnE,gBAAI,CAAC,6BAA6B;AAC9B,4CAA8B,CAAA;AAC9B,kCAAoB,aAAa,IAAI;AAAA,YACzC;AACA,wCAA4B,KAAK,YAAY;AAAA,UACjD;AAAA,QACJ,OACK;AACD,cAAI,8BAA8B,oBAAoB,aAAa;AACnE,cAAI,CAAC,6BAA6B;AAC9B,0CAA8B,CAAA;AAC9B,gCAAoB,aAAa,IAAI;AAAA,UACzC;AACA,sCAA4B,KAAK,aAAa;AAAA,QAClD;AAAA,MACJ;AAAA,IACJ;AAAA,EACJ;AACA,QAAM,oBAAoB,SAAS,SAAO,KAAK,UAAU,GAAG,CAAC;AAC7D,QAAM,WAAW,CAAA;AACjB,MAAI,cAAc,SAAS;AACvB,aAAS,KAAK,cAAc,OAAO;AAAA,EACvC;AACA,MAAI,cAAc,mBAAmB;AACjC,aAAS,KAAK,GAAG,cAAc,iBAAiB;AAAA,EACpD;AACA,aAAW,WAAW,UAAU;AAC5B,QAAI,QAAQ,YAAY,QAAQ;AAC5B,iBAAW,aAAa,QAAQ,YAAY;AACxC,cAAM,gBAAgB,UAAU,KAAK;AACrC,YAAI,8BAA8B,oBAAoB,aAAa;AACnE,YAAI,CAAC,6BAA6B;AAC9B,wCAA8B,CAAA;AAC9B,8BAAoB,aAAa,IAAI;AAAA,QACzC;AAEA,YAAI,QAAQ,CAAA;AAIZ,YAAI,UAAU,WAAW;AACrB,qBAAW,WAAW,UAAU,WAAW;AACvC,kBAAM,UAAU,QAAQ,KAAK;AAC7B,gBAAI,MAAM,OAAO,KAAK,KAAM;AAM5B,gBAAI,MAAM,OAAO,KAAK,MAAM;AACxB,oBAAM,OAAO,IAAI,oBAAoB,QAAQ,KAAK;AAAA,YACtD;AAAA,UACJ;AAAA,QACJ;AACA,YAAI,SAAS,SAAS,KAAK,4BAA4B,SAAS,GAAG;AAC/D,gBAAM,SAAS,kBAAkB,KAAK;AACtC,cAAI,4BAA4B,KAAK,SAAO,kBAAkB,GAAG,MAAM,MAAM,GAAG;AAC5E;AAAA,UACJ;AAAA,QACJ;AACA,oCAA4B,KAAK,KAAK;AAAA,MAC1C;AAAA,IACJ;AAAA,EACJ;AACA,SAAO;AACX;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/getObjectTypeFromTypeMap.js

@@ -0,0 +1,13 @@
+import { isObjectType } from "../../../graphql/type/definition.js";
+function getObjectTypeFromTypeMap(typeMap, type) {
+  if (type) {
+    const maybeObjectType = typeMap[type.name];
+    if (isObjectType(maybeObjectType)) {
+      return maybeObjectType;
+    }
+  }
+}
+export {
+  getObjectTypeFromTypeMap
+};
+//# sourceMappingURL=getObjectTypeFromTypeMap.js.map

package/dist/node_modules/@graphql-tools/utils/esm/getObjectTypeFromTypeMap.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"getObjectTypeFromTypeMap.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/getObjectTypeFromTypeMap.js"],"sourcesContent":["import { isObjectType } from 'graphql';\nexport function getObjectTypeFromTypeMap(typeMap, type) {\n    if (type) {\n        const maybeObjectType = typeMap[type.name];\n        if (isObjectType(maybeObjectType)) {\n            return maybeObjectType;\n        }\n    }\n}\n"],"names":[],"mappings":";AACO,SAAS,yBAAyB,SAAS,MAAM;AACpD,MAAI,MAAM;AACN,UAAM,kBAAkB,QAAQ,KAAK,IAAI;AACzC,QAAI,aAAa,eAAe,GAAG;AAC/B,aAAO;AAAA,IACX;AAAA,EACJ;AACJ;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/heal.js

@@ -0,0 +1,120 @@
+import { isObjectType, isInterfaceType, isUnionType, isInputObjectType, isLeafType, isListType, GraphQLList, isNonNullType, GraphQLNonNull, isNamedType } from "../../../graphql/type/definition.js";
+function healSchema(schema) {
+  healTypes(schema.getTypeMap(), schema.getDirectives());
+  return schema;
+}
+function healTypes(originalTypeMap, directives) {
+  const actualNamedTypeMap = /* @__PURE__ */ Object.create(null);
+  for (const typeName in originalTypeMap) {
+    const namedType = originalTypeMap[typeName];
+    if (namedType == null || typeName.startsWith("__")) {
+      continue;
+    }
+    const actualName = namedType.name;
+    if (actualName.startsWith("__")) {
+      continue;
+    }
+    if (actualNamedTypeMap[actualName] != null) {
+      console.warn(`Duplicate schema type name ${actualName} found; keeping the existing one found in the schema`);
+      continue;
+    }
+    actualNamedTypeMap[actualName] = namedType;
+  }
+  for (const typeName in actualNamedTypeMap) {
+    const namedType = actualNamedTypeMap[typeName];
+    originalTypeMap[typeName] = namedType;
+  }
+  for (const decl of directives) {
+    decl.args = decl.args.filter((arg) => {
+      arg.type = healType(arg.type);
+      return arg.type !== null;
+    });
+  }
+  for (const typeName in originalTypeMap) {
+    const namedType = originalTypeMap[typeName];
+    if (!typeName.startsWith("__") && typeName in actualNamedTypeMap) {
+      if (namedType != null) {
+        healNamedType(namedType);
+      }
+    }
+  }
+  for (const typeName in originalTypeMap) {
+    if (!typeName.startsWith("__") && !(typeName in actualNamedTypeMap)) {
+      delete originalTypeMap[typeName];
+    }
+  }
+  function healNamedType(type) {
+    if (isObjectType(type)) {
+      healFields(type);
+      healInterfaces(type);
+      return;
+    } else if (isInterfaceType(type)) {
+      healFields(type);
+      if ("getInterfaces" in type) {
+        healInterfaces(type);
+      }
+      return;
+    } else if (isUnionType(type)) {
+      healUnderlyingTypes(type);
+      return;
+    } else if (isInputObjectType(type)) {
+      healInputFields(type);
+      return;
+    } else if (isLeafType(type)) {
+      return;
+    }
+    throw new Error(`Unexpected schema type: ${type}`);
+  }
+  function healFields(type) {
+    const fieldMap = type.getFields();
+    for (const [key, field] of Object.entries(fieldMap)) {
+      field.args.map((arg) => {
+        arg.type = healType(arg.type);
+        return arg.type === null ? null : arg;
+      }).filter(Boolean);
+      field.type = healType(field.type);
+      if (field.type === null) {
+        delete fieldMap[key];
+      }
+    }
+  }
+  function healInterfaces(type) {
+    if ("getInterfaces" in type) {
+      const interfaces = type.getInterfaces();
+      interfaces.push(...interfaces.splice(0).map((iface) => healType(iface)).filter(Boolean));
+    }
+  }
+  function healInputFields(type) {
+    const fieldMap = type.getFields();
+    for (const [key, field] of Object.entries(fieldMap)) {
+      field.type = healType(field.type);
+      if (field.type === null) {
+        delete fieldMap[key];
+      }
+    }
+  }
+  function healUnderlyingTypes(type) {
+    const types = type.getTypes();
+    types.push(...types.splice(0).map((t) => healType(t)).filter(Boolean));
+  }
+  function healType(type) {
+    if (isListType(type)) {
+      const healedType = healType(type.ofType);
+      return healedType != null ? new GraphQLList(healedType) : null;
+    } else if (isNonNullType(type)) {
+      const healedType = healType(type.ofType);
+      return healedType != null ? new GraphQLNonNull(healedType) : null;
+    } else if (isNamedType(type)) {
+      const officialType = originalTypeMap[type.name];
+      if (officialType && type !== officialType) {
+        return officialType;
+      }
+    }
+    return type;
+  }
+}
+export {
+  healSchema,
+  healTypes
+};
+//# sourceMappingURL=heal.js.map

package/dist/node_modules/@graphql-tools/utils/esm/heal.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"heal.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/heal.js"],"sourcesContent":["import { GraphQLList, GraphQLNonNull, isInputObjectType, isInterfaceType, isLeafType, isListType, isNamedType, isNonNullType, isObjectType, isUnionType, } from 'graphql';\n// Update any references to named schema types that disagree with the named\n// types found in schema.getTypeMap().\n//\n// healSchema and its callers (visitSchema/visitSchemaDirectives) all modify the schema in place.\n// Therefore, private variables (such as the stored implementation map and the proper root types)\n// are not updated.\n//\n// If this causes issues, the schema could be more aggressively healed as follows:\n//\n// healSchema(schema);\n// const config = schema.toConfig()\n// const healedSchema = new GraphQLSchema({\n//   ...config,\n//   query: schema.getType('<desired new root query type name>'),\n//   mutation: schema.getType('<desired new root mutation type name>'),\n//   subscription: schema.getType('<desired new root subscription type name>'),\n// });\n//\n// One can then also -- if necessary --  assign the correct private variables to the initial schema\n// as follows:\n// Object.assign(schema, healedSchema);\n//\n// These steps are not taken automatically to preserve backwards compatibility with graphql-tools v4.\n// See https://github.com/ardatan/graphql-tools/issues/1462\n//\n// They were briefly taken in v5, but can now be phased out as they were only required when other\n// areas of the codebase were using healSchema and visitSchema more extensively.\n//\nexport function healSchema(schema) {\n    healTypes(schema.getTypeMap(), schema.getDirectives());\n    return schema;\n}\nexport function healTypes(originalTypeMap, directives) {\n    const actualNamedTypeMap = Object.create(null);\n    // If any of the .name properties of the GraphQLNamedType objects in\n    // schema.getTypeMap() have changed, the keys of the type map need to\n    // be updated accordingly.\n    for (const typeName in originalTypeMap) {\n        const namedType = originalTypeMap[typeName];\n        if (namedType == null || typeName.startsWith('__')) {\n            continue;\n        }\n        const actualName = namedType.name;\n        if (actualName.startsWith('__')) {\n            continue;\n        }\n        if (actualNamedTypeMap[actualName] != null) {\n            console.warn(`Duplicate schema type name ${actualName} found; keeping the existing one found in the schema`);\n            continue;\n        }\n        actualNamedTypeMap[actualName] = namedType;\n        // Note: we are deliberately leaving namedType in the schema by its\n        // original name (which might be different from actualName), so that\n        // references by that name can be healed.\n    }\n    // Now add back every named type by its actual name.\n    for (const typeName in actualNamedTypeMap) {\n        const namedType = actualNamedTypeMap[typeName];\n        originalTypeMap[typeName] = namedType;\n    }\n    // Directive declaration argument types can refer to named types.\n    for (const decl of directives) {\n        decl.args = decl.args.filter(arg => {\n            arg.type = healType(arg.type);\n            return arg.type !== null;\n        });\n    }\n    for (const typeName in originalTypeMap) {\n        const namedType = originalTypeMap[typeName];\n        // Heal all named types, except for dangling references, kept only to redirect.\n        if (!typeName.startsWith('__') && typeName in actualNamedTypeMap) {\n            if (namedType != null) {\n                healNamedType(namedType);\n            }\n        }\n    }\n    for (const typeName in originalTypeMap) {\n        if (!typeName.startsWith('__') && !(typeName in actualNamedTypeMap)) {\n            delete originalTypeMap[typeName];\n        }\n    }\n    function healNamedType(type) {\n        if (isObjectType(type)) {\n            healFields(type);\n            healInterfaces(type);\n            return;\n        }\n        else if (isInterfaceType(type)) {\n            healFields(type);\n            if ('getInterfaces' in type) {\n                healInterfaces(type);\n            }\n            return;\n        }\n        else if (isUnionType(type)) {\n            healUnderlyingTypes(type);\n            return;\n        }\n        else if (isInputObjectType(type)) {\n            healInputFields(type);\n            return;\n        }\n        else if (isLeafType(type)) {\n            return;\n        }\n        throw new Error(`Unexpected schema type: ${type}`);\n    }\n    function healFields(type) {\n        const fieldMap = type.getFields();\n        for (const [key, field] of Object.entries(fieldMap)) {\n            field.args\n                .map(arg => {\n                arg.type = healType(arg.type);\n                return arg.type === null ? null : arg;\n            })\n                .filter(Boolean);\n            field.type = healType(field.type);\n            if (field.type === null) {\n                delete fieldMap[key];\n            }\n        }\n    }\n    function healInterfaces(type) {\n        if ('getInterfaces' in type) {\n            const interfaces = type.getInterfaces();\n            interfaces.push(...interfaces\n                .splice(0)\n                .map(iface => healType(iface))\n                .filter(Boolean));\n        }\n    }\n    function healInputFields(type) {\n        const fieldMap = type.getFields();\n        for (const [key, field] of Object.entries(fieldMap)) {\n            field.type = healType(field.type);\n            if (field.type === null) {\n                delete fieldMap[key];\n            }\n        }\n    }\n    function healUnderlyingTypes(type) {\n        const types = type.getTypes();\n        types.push(...types\n            .splice(0)\n            .map(t => healType(t))\n            .filter(Boolean));\n    }\n    function healType(type) {\n        // Unwrap the two known wrapper types\n        if (isListType(type)) {\n            const healedType = healType(type.ofType);\n            return healedType != null ? new GraphQLList(healedType) : null;\n        }\n        else if (isNonNullType(type)) {\n            const healedType = healType(type.ofType);\n            return healedType != null ? new GraphQLNonNull(healedType) : null;\n        }\n        else if (isNamedType(type)) {\n            // If a type annotation on a field or an argument or a union member is\n            // any `GraphQLNamedType` with a `name`, then it must end up identical\n            // to `schema.getType(name)`, since `schema.getTypeMap()` is the source\n            // of truth for all named schema types.\n            // Note that new types can still be simply added by adding a field, as\n            // the official type will be undefined, not null.\n            const officialType = originalTypeMap[type.name];\n            if (officialType && type !== officialType) {\n                return officialType;\n            }\n        }\n        return type;\n    }\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/helpers.js

@@ -0,0 +1,42 @@
+const asArray = (fns) => Array.isArray(fns) ? fns : fns ? [fns] : [];
+function compareStrings(a, b) {
+  if (String(a) < String(b)) {
+    return -1;
+  }
+  if (String(a) > String(b)) {
+    return 1;
+  }
+  return 0;
+}
+function nodeToString(a) {
+  let name;
+  if ("alias" in a) {
+    name = a.alias?.value;
+  }
+  if (name == null && "name" in a) {
+    name = a.name?.value;
+  }
+  if (name == null) {
+    name = a.kind;
+  }
+  return name;
+}
+function compareNodes(a, b, customFn) {
+  const aStr = nodeToString(a);
+  const bStr = nodeToString(b);
+  if (typeof customFn === "function") {
+    return customFn(aStr, bStr);
+  }
+  return compareStrings(aStr, bStr);
+}
+function isSome(input) {
+  return input != null;
+}
+export {
+  asArray,
+  compareNodes,
+  compareStrings,
+  isSome,
+  nodeToString
+};
+//# sourceMappingURL=helpers.js.map

package/dist/node_modules/@graphql-tools/utils/esm/helpers.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"helpers.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/helpers.js"],"sourcesContent":["import { parse } from 'graphql';\nconst URL_REGEXP = /^(https?|wss?|file):\\/\\//;\n/**\n * Checks if the given string is a valid URL.\n *\n * @param str - The string to validate as a URL\n * @returns A boolean indicating whether the string is a valid URL\n *\n * @remarks\n * This function first attempts to use the `URL.canParse` method if available.\n * If not, it falls back to creating a new `URL` object to validate the string.\n */\nexport function isUrl(str) {\n    if (typeof str !== 'string') {\n        return false;\n    }\n    if (!URL_REGEXP.test(str)) {\n        return false;\n    }\n    if (URL.canParse) {\n        return URL.canParse(str);\n    }\n    try {\n        const url = new URL(str);\n        return !!url;\n    }\n    catch (e) {\n        return false;\n    }\n}\nexport const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);\nconst invalidDocRegex = /\\.[a-z0-9]+$/i;\n/**\n * Determines if a given input is a valid GraphQL document string.\n *\n * @param str - The input to validate as a GraphQL document\n * @returns A boolean indicating whether the input is a valid GraphQL document string\n *\n * @remarks\n * This function performs several validation checks:\n * - Ensures the input is a string\n * - Filters out strings with invalid document extensions\n * - Excludes URLs\n * - Attempts to parse the string as a GraphQL document\n *\n * @throws {Error} If the document fails to parse and is empty except GraphQL comments\n */\nexport function isDocumentString(str) {\n    if (typeof str !== 'string') {\n        return false;\n    }\n    // XXX: is-valid-path or is-glob treat SDL as a valid path\n    // (`scalar Date` for example)\n    // this why checking the extension is fast enough\n    // and prevent from parsing the string in order to find out\n    // if the string is a SDL\n    if (invalidDocRegex.test(str) || isUrl(str)) {\n        return false;\n    }\n    try {\n        parse(str);\n        return true;\n    }\n    catch (e) {\n        if (!e.message.includes('EOF') &&\n            str.replace(/(\\#[^*]*)/g, '').trim() !== '' &&\n            str.includes(' ')) {\n            throw new Error(`Failed to parse the GraphQL document. ${e.message}\\n${str}`);\n        }\n    }\n    return false;\n}\nconst invalidPathRegex = /[‘“!%^<>`\\n]/;\n/**\n * Checkes whether the `str` contains any path illegal characters.\n *\n * A string may sometimes look like a path but is not (like an SDL of a simple\n * GraphQL schema). To make sure we don't yield false-positives in such cases,\n * we disallow new lines in paths (even though most Unix systems support new\n * lines in file names).\n */\nexport function isValidPath(str) {\n    return typeof str === 'string' && !invalidPathRegex.test(str);\n}\nexport function compareStrings(a, b) {\n    if (String(a) < String(b)) {\n        return -1;\n    }\n    if (String(a) > String(b)) {\n        return 1;\n    }\n    return 0;\n}\nexport function nodeToString(a) {\n    let name;\n    if ('alias' in a) {\n        name = a.alias?.value;\n    }\n    if (name == null && 'name' in a) {\n        name = a.name?.value;\n    }\n    if (name == null) {\n        name = a.kind;\n    }\n    return name;\n}\nexport function compareNodes(a, b, customFn) {\n    const aStr = nodeToString(a);\n    const bStr = nodeToString(b);\n    if (typeof customFn === 'function') {\n        return customFn(aStr, bStr);\n    }\n    return compareStrings(aStr, bStr);\n}\nexport function isSome(input) {\n    return input != null;\n}\nexport function assertSome(input, message = 'Value should be something') {\n    if (input == null) {\n        throw new Error(message);\n    }\n}\n"],"names":[],"mappings":"AA8BY,MAAC,UAAU,CAAC,QAAS,MAAM,QAAQ,GAAG,IAAI,MAAM,MAAM,CAAC,GAAG,IAAI,CAAA;AAsDnE,SAAS,eAAe,GAAG,GAAG;AACjC,MAAI,OAAO,CAAC,IAAI,OAAO,CAAC,GAAG;AACvB,WAAO;AAAA,EACX;AACA,MAAI,OAAO,CAAC,IAAI,OAAO,CAAC,GAAG;AACvB,WAAO;AAAA,EACX;AACA,SAAO;AACX;AACO,SAAS,aAAa,GAAG;AAC5B,MAAI;AACJ,MAAI,WAAW,GAAG;AACd,WAAO,EAAE,OAAO;AAAA,EACpB;AACA,MAAI,QAAQ,QAAQ,UAAU,GAAG;AAC7B,WAAO,EAAE,MAAM;AAAA,EACnB;AACA,MAAI,QAAQ,MAAM;AACd,WAAO,EAAE;AAAA,EACb;AACA,SAAO;AACX;AACO,SAAS,aAAa,GAAG,GAAG,UAAU;AACzC,QAAM,OAAO,aAAa,CAAC;AAC3B,QAAM,OAAO,aAAa,CAAC;AAC3B,MAAI,OAAO,aAAa,YAAY;AAChC,WAAO,SAAS,MAAM,IAAI;AAAA,EAC9B;AACA,SAAO,eAAe,MAAM,IAAI;AACpC;AACO,SAAS,OAAO,OAAO;AAC1B,SAAO,SAAS;AACpB;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/isAsyncIterable.js

@@ -0,0 +1,7 @@
+function isAsyncIterable(value) {
+  return value?.[Symbol.asyncIterator] != null;
+}
+export {
+  isAsyncIterable
+};
+//# sourceMappingURL=isAsyncIterable.js.map

package/dist/node_modules/@graphql-tools/utils/esm/isAsyncIterable.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isAsyncIterable.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/isAsyncIterable.js"],"sourcesContent":["export function isAsyncIterable(value) {\n    return value?.[Symbol.asyncIterator] != null;\n}\n"],"names":[],"mappings":"AAAO,SAAS,gBAAgB,OAAO;AACnC,SAAO,QAAQ,OAAO,aAAa,KAAK;AAC5C;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/isDocumentNode.js

@@ -0,0 +1,8 @@
+import { Kind } from "../../../graphql/language/kinds.js";
+function isDocumentNode(object) {
+  return object && typeof object === "object" && "kind" in object && object.kind === Kind.DOCUMENT;
+}
+export {
+  isDocumentNode
+};
+//# sourceMappingURL=isDocumentNode.js.map

package/dist/node_modules/@graphql-tools/utils/esm/isDocumentNode.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"isDocumentNode.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/isDocumentNode.js"],"sourcesContent":["import { Kind } from 'graphql';\nexport function isDocumentNode(object) {\n    return object && typeof object === 'object' && 'kind' in object && object.kind === Kind.DOCUMENT;\n}\n"],"names":[],"mappings":";AACO,SAAS,eAAe,QAAQ;AACnC,SAAO,UAAU,OAAO,WAAW,YAAY,UAAU,UAAU,OAAO,SAAS,KAAK;AAC5F;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/utils/esm/jsutils.js

@@ -0,0 +1,26 @@
+import { handleMaybePromise } from "../../../@whatwg-node/promise-helpers/esm/index.js";
+import { isPromise } from "../../../@whatwg-node/promise-helpers/esm/index.js";
+function isIterableObject(value) {
+  return value != null && typeof value === "object" && Symbol.iterator in value;
+}
+function isObjectLike(value) {
+  return typeof value === "object" && value !== null;
+}
+function promiseReduce(values, callbackFn, initialValue) {
+  let accumulator = initialValue;
+  for (const value of values) {
+    accumulator = handleMaybePromise(() => accumulator, (resolved) => callbackFn(resolved, value));
+  }
+  return accumulator;
+}
+function hasOwnProperty(obj, prop) {
+  return Object.prototype.hasOwnProperty.call(obj, prop);
+}
+export {
+  hasOwnProperty,
+  isIterableObject,
+  isObjectLike,
+  isPromise,
+  promiseReduce
+};
+//# sourceMappingURL=jsutils.js.map

package/dist/node_modules/@graphql-tools/utils/esm/jsutils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"jsutils.js","sources":["../../../../../node_modules/@graphql-tools/utils/esm/jsutils.js"],"sourcesContent":["import { handleMaybePromise, isPromise } from '@whatwg-node/promise-helpers';\nexport function isIterableObject(value) {\n    return value != null && typeof value === 'object' && Symbol.iterator in value;\n}\nexport function isObjectLike(value) {\n    return typeof value === 'object' && value !== null;\n}\nexport { isPromise };\nexport function promiseReduce(values, callbackFn, initialValue) {\n    let accumulator = initialValue;\n    for (const value of values) {\n        accumulator = handleMaybePromise(() => accumulator, resolved => callbackFn(resolved, value));\n    }\n    return accumulator;\n}\nexport function hasOwnProperty(obj, prop) {\n    return Object.prototype.hasOwnProperty.call(obj, prop);\n}\n"],"names":[],"mappings":";;AACO,SAAS,iBAAiB,OAAO;AACpC,SAAO,SAAS,QAAQ,OAAO,UAAU,YAAY,OAAO,YAAY;AAC5E;AACO,SAAS,aAAa,OAAO;AAChC,SAAO,OAAO,UAAU,YAAY,UAAU;AAClD;AAEO,SAAS,cAAc,QAAQ,YAAY,cAAc;AAC5D,MAAI,cAAc;AAClB,aAAW,SAAS,QAAQ;AACxB,kBAAc,mBAAmB,MAAM,aAAa,cAAY,WAAW,UAAU,KAAK,CAAC;AAAA,EAC/F;AACA,SAAO;AACX;AACO,SAAS,eAAe,KAAK,MAAM;AACtC,SAAO,OAAO,UAAU,eAAe,KAAK,KAAK,IAAI;AACzD;","x_google_ignoreList":[0]}