@weavelogic/knowledge-graph-agent 0.3.0 → 0.6.0

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-nodes.js

@@ -0,0 +1,81 @@
+import { mergeDirective } from "./directives.js";
+import { mergeEnum } from "./enum.js";
+import { mergeInputType } from "./input-type.js";
+import { mergeInterface } from "./interface.js";
+import { mergeScalar } from "./scalar.js";
+import { mergeSchemaDefs } from "./schema-def.js";
+import { mergeType } from "./type.js";
+import { mergeUnion } from "./union.js";
+import { collectComment } from "../../../utils/esm/comments.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+const schemaDefSymbol = "SCHEMA_DEF_SYMBOL";
+function isNamedDefinitionNode(definitionNode) {
+  return "name" in definitionNode;
+}
+function mergeGraphQLNodes(nodes, config, directives = {}) {
+  const mergedResultMap = directives;
+  for (const nodeDefinition of nodes) {
+    if (isNamedDefinitionNode(nodeDefinition)) {
+      const name = nodeDefinition.name?.value;
+      if (config?.commentDescriptions) {
+        collectComment(nodeDefinition);
+      }
+      if (name == null) {
+        continue;
+      }
+      if (config?.exclusions?.includes(name + ".*") || config?.exclusions?.includes(name)) {
+        delete mergedResultMap[name];
+      } else {
+        switch (nodeDefinition.kind) {
+          case Kind.OBJECT_TYPE_DEFINITION:
+          case Kind.OBJECT_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.ENUM_TYPE_DEFINITION:
+          case Kind.ENUM_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.UNION_TYPE_DEFINITION:
+          case Kind.UNION_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.SCALAR_TYPE_DEFINITION:
+          case Kind.SCALAR_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.INPUT_OBJECT_TYPE_DEFINITION:
+          case Kind.INPUT_OBJECT_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.INTERFACE_TYPE_DEFINITION:
+          case Kind.INTERFACE_TYPE_EXTENSION:
+            mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config, directives);
+            break;
+          case Kind.DIRECTIVE_DEFINITION:
+            if (mergedResultMap[name]) {
+              const isInheritedFromPrototype = name in {};
+              if (isInheritedFromPrototype) {
+                if (!isASTNode(mergedResultMap[name])) {
+                  mergedResultMap[name] = void 0;
+                }
+              }
+            }
+            mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);
+            break;
+        }
+      }
+    } else if (nodeDefinition.kind === Kind.SCHEMA_DEFINITION || nodeDefinition.kind === Kind.SCHEMA_EXTENSION) {
+      mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);
+    }
+  }
+  return mergedResultMap;
+}
+function isASTNode(node) {
+  return node != null && typeof node === "object" && "kind" in node && typeof node.kind === "string";
+}
+export {
+  isNamedDefinitionNode,
+  mergeGraphQLNodes,
+  schemaDefSymbol
+};
+//# sourceMappingURL=merge-nodes.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-nodes.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-nodes.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-nodes.js"],"sourcesContent":["import { Kind, } from 'graphql';\nimport { collectComment } from '@graphql-tools/utils';\nimport { mergeDirective } from './directives.js';\nimport { mergeEnum } from './enum.js';\nimport { mergeInputType } from './input-type.js';\nimport { mergeInterface } from './interface.js';\nimport { mergeScalar } from './scalar.js';\nimport { mergeSchemaDefs } from './schema-def.js';\nimport { mergeType } from './type.js';\nimport { mergeUnion } from './union.js';\nexport const schemaDefSymbol = 'SCHEMA_DEF_SYMBOL';\nexport function isNamedDefinitionNode(definitionNode) {\n    return 'name' in definitionNode;\n}\nexport function mergeGraphQLNodes(nodes, config, directives = {}) {\n    const mergedResultMap = directives;\n    for (const nodeDefinition of nodes) {\n        if (isNamedDefinitionNode(nodeDefinition)) {\n            const name = nodeDefinition.name?.value;\n            if (config?.commentDescriptions) {\n                collectComment(nodeDefinition);\n            }\n            if (name == null) {\n                continue;\n            }\n            if (config?.exclusions?.includes(name + '.*') || config?.exclusions?.includes(name)) {\n                delete mergedResultMap[name];\n            }\n            else {\n                switch (nodeDefinition.kind) {\n                    case Kind.OBJECT_TYPE_DEFINITION:\n                    case Kind.OBJECT_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeType(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.ENUM_TYPE_DEFINITION:\n                    case Kind.ENUM_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeEnum(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.UNION_TYPE_DEFINITION:\n                    case Kind.UNION_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeUnion(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.SCALAR_TYPE_DEFINITION:\n                    case Kind.SCALAR_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeScalar(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.INPUT_OBJECT_TYPE_DEFINITION:\n                    case Kind.INPUT_OBJECT_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeInputType(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.INTERFACE_TYPE_DEFINITION:\n                    case Kind.INTERFACE_TYPE_EXTENSION:\n                        mergedResultMap[name] = mergeInterface(nodeDefinition, mergedResultMap[name], config, directives);\n                        break;\n                    case Kind.DIRECTIVE_DEFINITION:\n                        if (mergedResultMap[name]) {\n                            const isInheritedFromPrototype = name in {}; // i.e. toString\n                            if (isInheritedFromPrototype) {\n                                if (!isASTNode(mergedResultMap[name])) {\n                                    mergedResultMap[name] = undefined;\n                                }\n                            }\n                        }\n                        mergedResultMap[name] = mergeDirective(nodeDefinition, mergedResultMap[name]);\n                        break;\n                }\n            }\n        }\n        else if (nodeDefinition.kind === Kind.SCHEMA_DEFINITION ||\n            nodeDefinition.kind === Kind.SCHEMA_EXTENSION) {\n            mergedResultMap[schemaDefSymbol] = mergeSchemaDefs(nodeDefinition, mergedResultMap[schemaDefSymbol], config);\n        }\n    }\n    return mergedResultMap;\n}\nfunction isASTNode(node) {\n    return (node != null && typeof node === 'object' && 'kind' in node && typeof node.kind === 'string');\n}\n"],"names":[],"mappings":";;;;;;;;;;AAUY,MAAC,kBAAkB;AACxB,SAAS,sBAAsB,gBAAgB;AAClD,SAAO,UAAU;AACrB;AACO,SAAS,kBAAkB,OAAO,QAAQ,aAAa,CAAA,GAAI;AAC9D,QAAM,kBAAkB;AACxB,aAAW,kBAAkB,OAAO;AAChC,QAAI,sBAAsB,cAAc,GAAG;AACvC,YAAM,OAAO,eAAe,MAAM;AAClC,UAAI,QAAQ,qBAAqB;AAC7B,uBAAe,cAAc;AAAA,MACjC;AACA,UAAI,QAAQ,MAAM;AACd;AAAA,MACJ;AACA,UAAI,QAAQ,YAAY,SAAS,OAAO,IAAI,KAAK,QAAQ,YAAY,SAAS,IAAI,GAAG;AACjF,eAAO,gBAAgB,IAAI;AAAA,MAC/B,OACK;AACD,gBAAQ,eAAe,MAAI;AAAA,UACvB,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,UAAU,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAC3F;AAAA,UACJ,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,UAAU,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAC3F;AAAA,UACJ,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,WAAW,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAC5F;AAAA,UACJ,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,YAAY,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAC7F;AAAA,UACJ,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,eAAe,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAChG;AAAA,UACJ,KAAK,KAAK;AAAA,UACV,KAAK,KAAK;AACN,4BAAgB,IAAI,IAAI,eAAe,gBAAgB,gBAAgB,IAAI,GAAG,QAAQ,UAAU;AAChG;AAAA,UACJ,KAAK,KAAK;AACN,gBAAI,gBAAgB,IAAI,GAAG;AACvB,oBAAM,2BAA2B,QAAQ;AACzC,kBAAI,0BAA0B;AAC1B,oBAAI,CAAC,UAAU,gBAAgB,IAAI,CAAC,GAAG;AACnC,kCAAgB,IAAI,IAAI;AAAA,gBAC5B;AAAA,cACJ;AAAA,YACJ;AACA,4BAAgB,IAAI,IAAI,eAAe,gBAAgB,gBAAgB,IAAI,CAAC;AAC5E;AAAA,QACxB;AAAA,MACY;AAAA,IACJ,WACS,eAAe,SAAS,KAAK,qBAClC,eAAe,SAAS,KAAK,kBAAkB;AAC/C,sBAAgB,eAAe,IAAI,gBAAgB,gBAAgB,gBAAgB,eAAe,GAAG,MAAM;AAAA,IAC/G;AAAA,EACJ;AACA,SAAO;AACX;AACA,SAAS,UAAU,MAAM;AACrB,SAAQ,QAAQ,QAAQ,OAAO,SAAS,YAAY,UAAU,QAAQ,OAAO,KAAK,SAAS;AAC/F;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-typedefs.js

@@ -0,0 +1,142 @@
+import { extractLinks, resolveImportName } from "../links.js";
+import { mergeGraphQLNodes, schemaDefSymbol } from "./merge-nodes.js";
+import { DEFAULT_OPERATION_TYPE_NAME_MAP } from "./schema-def.js";
+import { defaultStringComparator, isStringTypes, isSourceTypes } from "./utils.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+import { printWithComments, resetComments } from "../../../utils/esm/comments.js";
+import { isSchema } from "../../../../graphql/type/schema.js";
+import { getDocumentNodeFromSchema } from "../../../utils/esm/print-schema-with-directives.js";
+import { parse } from "../../../../graphql/language/parser.js";
+import { isDefinitionNode } from "../../../../graphql/language/predicates.js";
+import { isDocumentNode } from "../../../utils/esm/isDocumentNode.js";
+function mergeTypeDefs(typeSource, config) {
+  resetComments();
+  const doc = {
+    kind: Kind.DOCUMENT,
+    definitions: mergeGraphQLTypes(typeSource, {
+      useSchemaDefinition: true,
+      forceSchemaDefinition: false,
+      throwOnConflict: false,
+      commentDescriptions: false,
+      ...config
+    })
+  };
+  let result;
+  if (config?.commentDescriptions) {
+    result = printWithComments(doc);
+  } else {
+    result = doc;
+  }
+  resetComments();
+  return result;
+}
+function visitTypeSources(typeSource, options, allDirectives = [], allNodes = [], visitedTypeSources = /* @__PURE__ */ new Set(), repeatableLinkImports = /* @__PURE__ */ new Set()) {
+  const addRepeatable = (name) => {
+    repeatableLinkImports.add(name);
+  };
+  if (typeSource && !visitedTypeSources.has(typeSource)) {
+    visitedTypeSources.add(typeSource);
+    if (typeof typeSource === "function") {
+      visitTypeSources(typeSource(), options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);
+    } else if (Array.isArray(typeSource)) {
+      for (const type of typeSource) {
+        visitTypeSources(type, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);
+      }
+    } else if (isSchema(typeSource)) {
+      const documentNode = getDocumentNodeFromSchema(typeSource, options);
+      visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);
+    } else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {
+      const documentNode = parse(typeSource, options);
+      visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);
+    } else if (typeof typeSource === "object" && isDefinitionNode(typeSource)) {
+      const links = extractLinks({
+        definitions: [typeSource],
+        kind: Kind.DOCUMENT
+      });
+      const federationUrl = "https://specs.apollo.dev/federation";
+      const linkUrl = "https://specs.apollo.dev/link";
+      const federationLink = links.find((l) => l.url.identity === federationUrl);
+      if (federationLink) {
+        addRepeatable(resolveImportName(federationLink, "@composeDirective"));
+        addRepeatable(resolveImportName(federationLink, "@key"));
+      }
+      const linkLink = links.find((l) => l.url.identity === linkUrl);
+      if (linkLink) {
+        addRepeatable(resolveImportName(linkLink, "@link"));
+      }
+      if (typeSource.kind === Kind.DIRECTIVE_DEFINITION) {
+        allDirectives.push(typeSource);
+      } else {
+        allNodes.push(typeSource);
+      }
+    } else if (isDocumentNode(typeSource)) {
+      visitTypeSources(typeSource.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);
+    } else {
+      throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);
+    }
+  }
+  return { allDirectives, allNodes, repeatableLinkImports };
+}
+function mergeGraphQLTypes(typeSource, config) {
+  resetComments();
+  const { allDirectives, allNodes, repeatableLinkImports } = visitTypeSources(typeSource, config);
+  const mergedDirectives = mergeGraphQLNodes(allDirectives, config);
+  config.repeatableLinkImports = repeatableLinkImports;
+  const mergedNodes = mergeGraphQLNodes(allNodes, config, mergedDirectives);
+  if (config?.useSchemaDefinition) {
+    const schemaDef = mergedNodes[schemaDefSymbol] || {
+      kind: Kind.SCHEMA_DEFINITION,
+      operationTypes: []
+    };
+    const operationTypes = schemaDef.operationTypes;
+    for (const opTypeDefNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {
+      const opTypeDefNode = operationTypes.find((operationType) => operationType.operation === opTypeDefNodeType);
+      if (!opTypeDefNode) {
+        const possibleRootTypeName = DEFAULT_OPERATION_TYPE_NAME_MAP[opTypeDefNodeType];
+        const existingPossibleRootType = mergedNodes[possibleRootTypeName];
+        if (existingPossibleRootType != null && existingPossibleRootType.name != null) {
+          operationTypes.push({
+            kind: Kind.OPERATION_TYPE_DEFINITION,
+            type: {
+              kind: Kind.NAMED_TYPE,
+              name: existingPossibleRootType.name
+            },
+            operation: opTypeDefNodeType
+          });
+        }
+      }
+    }
+    if (schemaDef?.operationTypes?.length != null && schemaDef.operationTypes.length > 0) {
+      mergedNodes[schemaDefSymbol] = schemaDef;
+    }
+  }
+  if (config?.forceSchemaDefinition && !mergedNodes[schemaDefSymbol]?.operationTypes?.length) {
+    mergedNodes[schemaDefSymbol] = {
+      kind: Kind.SCHEMA_DEFINITION,
+      operationTypes: [
+        {
+          kind: Kind.OPERATION_TYPE_DEFINITION,
+          operation: "query",
+          type: {
+            kind: Kind.NAMED_TYPE,
+            name: {
+              kind: Kind.NAME,
+              value: "Query"
+            }
+          }
+        }
+      ]
+    };
+  }
+  const mergedNodeDefinitions = Object.values(mergedNodes);
+  if (config?.sort) {
+    const sortFn = typeof config.sort === "function" ? config.sort : defaultStringComparator;
+    mergedNodeDefinitions.sort((a, b) => sortFn(a.name?.value, b.name?.value));
+  }
+  return mergedNodeDefinitions;
+}
+export {
+  mergeGraphQLTypes,
+  mergeTypeDefs
+};
+//# sourceMappingURL=merge-typedefs.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-typedefs.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"merge-typedefs.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/merge-typedefs.js"],"sourcesContent":["import { isDefinitionNode, isSchema, Kind, parse, } from 'graphql';\nimport { getDocumentNodeFromSchema, isDocumentNode, printWithComments, resetComments, } from '@graphql-tools/utils';\nimport { extractLinks, resolveImportName } from '../links.js';\nimport { mergeGraphQLNodes, schemaDefSymbol } from './merge-nodes.js';\nimport { DEFAULT_OPERATION_TYPE_NAME_MAP } from './schema-def.js';\nimport { defaultStringComparator, isSourceTypes, isStringTypes } from './utils.js';\nexport function mergeTypeDefs(typeSource, config) {\n    resetComments();\n    const doc = {\n        kind: Kind.DOCUMENT,\n        definitions: mergeGraphQLTypes(typeSource, {\n            useSchemaDefinition: true,\n            forceSchemaDefinition: false,\n            throwOnConflict: false,\n            commentDescriptions: false,\n            ...config,\n        }),\n    };\n    let result;\n    if (config?.commentDescriptions) {\n        result = printWithComments(doc);\n    }\n    else {\n        result = doc;\n    }\n    resetComments();\n    return result;\n}\nfunction visitTypeSources(typeSource, options, allDirectives = [], allNodes = [], visitedTypeSources = new Set(), repeatableLinkImports = new Set()) {\n    const addRepeatable = (name) => {\n        repeatableLinkImports.add(name);\n    };\n    if (typeSource && !visitedTypeSources.has(typeSource)) {\n        visitedTypeSources.add(typeSource);\n        if (typeof typeSource === 'function') {\n            visitTypeSources(typeSource(), options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);\n        }\n        else if (Array.isArray(typeSource)) {\n            for (const type of typeSource) {\n                visitTypeSources(type, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);\n            }\n        }\n        else if (isSchema(typeSource)) {\n            const documentNode = getDocumentNodeFromSchema(typeSource, options);\n            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);\n        }\n        else if (isStringTypes(typeSource) || isSourceTypes(typeSource)) {\n            const documentNode = parse(typeSource, options);\n            visitTypeSources(documentNode.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);\n        }\n        else if (typeof typeSource === 'object' && isDefinitionNode(typeSource)) {\n            const links = extractLinks({\n                definitions: [typeSource],\n                kind: Kind.DOCUMENT,\n            });\n            const federationUrl = 'https://specs.apollo.dev/federation';\n            const linkUrl = 'https://specs.apollo.dev/link';\n            /**\n             * Official Federated imports are special because they can be referenced without specifyin the import.\n             * To handle this case, we must prepare a list of all the possible valid usages to check against.\n             * Note that this versioning is not technically correct, since some definitions are after v2.0.\n             * But this is enough information to be comfortable not blocking the imports at this phase. It's\n             * the job of the composer to validate the versions.\n             * */\n            const federationLink = links.find(l => l.url.identity === federationUrl);\n            if (federationLink) {\n                addRepeatable(resolveImportName(federationLink, '@composeDirective'));\n                addRepeatable(resolveImportName(federationLink, '@key'));\n            }\n            const linkLink = links.find(l => l.url.identity === linkUrl);\n            if (linkLink) {\n                addRepeatable(resolveImportName(linkLink, '@link'));\n            }\n            if (typeSource.kind === Kind.DIRECTIVE_DEFINITION) {\n                allDirectives.push(typeSource);\n            }\n            else {\n                allNodes.push(typeSource);\n            }\n        }\n        else if (isDocumentNode(typeSource)) {\n            visitTypeSources(typeSource.definitions, options, allDirectives, allNodes, visitedTypeSources, repeatableLinkImports);\n        }\n        else {\n            throw new Error(`typeDefs must contain only strings, documents, schemas, or functions, got ${typeof typeSource}`);\n        }\n    }\n    return { allDirectives, allNodes, repeatableLinkImports };\n}\nexport function mergeGraphQLTypes(typeSource, config) {\n    resetComments();\n    const { allDirectives, allNodes, repeatableLinkImports } = visitTypeSources(typeSource, config);\n    const mergedDirectives = mergeGraphQLNodes(allDirectives, config);\n    config.repeatableLinkImports = repeatableLinkImports;\n    const mergedNodes = mergeGraphQLNodes(allNodes, config, mergedDirectives);\n    if (config?.useSchemaDefinition) {\n        // XXX: right now we don't handle multiple schema definitions\n        const schemaDef = mergedNodes[schemaDefSymbol] || {\n            kind: Kind.SCHEMA_DEFINITION,\n            operationTypes: [],\n        };\n        const operationTypes = schemaDef.operationTypes;\n        for (const opTypeDefNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {\n            const opTypeDefNode = operationTypes.find(operationType => operationType.operation === opTypeDefNodeType);\n            if (!opTypeDefNode) {\n                const possibleRootTypeName = DEFAULT_OPERATION_TYPE_NAME_MAP[opTypeDefNodeType];\n                const existingPossibleRootType = mergedNodes[possibleRootTypeName];\n                if (existingPossibleRootType != null && existingPossibleRootType.name != null) {\n                    operationTypes.push({\n                        kind: Kind.OPERATION_TYPE_DEFINITION,\n                        type: {\n                            kind: Kind.NAMED_TYPE,\n                            name: existingPossibleRootType.name,\n                        },\n                        operation: opTypeDefNodeType,\n                    });\n                }\n            }\n        }\n        if (schemaDef?.operationTypes?.length != null && schemaDef.operationTypes.length > 0) {\n            mergedNodes[schemaDefSymbol] = schemaDef;\n        }\n    }\n    if (config?.forceSchemaDefinition && !mergedNodes[schemaDefSymbol]?.operationTypes?.length) {\n        mergedNodes[schemaDefSymbol] = {\n            kind: Kind.SCHEMA_DEFINITION,\n            operationTypes: [\n                {\n                    kind: Kind.OPERATION_TYPE_DEFINITION,\n                    operation: 'query',\n                    type: {\n                        kind: Kind.NAMED_TYPE,\n                        name: {\n                            kind: Kind.NAME,\n                            value: 'Query',\n                        },\n                    },\n                },\n            ],\n        };\n    }\n    const mergedNodeDefinitions = Object.values(mergedNodes);\n    if (config?.sort) {\n        const sortFn = typeof config.sort === 'function' ? config.sort : defaultStringComparator;\n        mergedNodeDefinitions.sort((a, b) => sortFn(a.name?.value, b.name?.value));\n    }\n    return mergedNodeDefinitions;\n}\n"],"names":[],"mappings":"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","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/scalar.js

@@ -0,0 +1,21 @@
+import { mergeDirectives } from "./directives.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+function mergeScalar(node, existingNode, config, directives) {
+  if (existingNode) {
+    return {
+      name: node.name,
+      description: node["description"] || existingNode["description"],
+      kind: config?.convertExtensions || node.kind === "ScalarTypeDefinition" || existingNode.kind === "ScalarTypeDefinition" ? "ScalarTypeDefinition" : "ScalarTypeExtension",
+      loc: node.loc,
+      directives: mergeDirectives(node.directives, existingNode.directives, config, directives)
+    };
+  }
+  return config?.convertExtensions ? {
+    ...node,
+    kind: Kind.SCALAR_TYPE_DEFINITION
+  } : node;
+}
+export {
+  mergeScalar
+};
+//# sourceMappingURL=scalar.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/scalar.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"scalar.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/scalar.js"],"sourcesContent":["import { Kind, } from 'graphql';\nimport { mergeDirectives } from './directives.js';\nexport function mergeScalar(node, existingNode, config, directives) {\n    if (existingNode) {\n        return {\n            name: node.name,\n            description: node['description'] || existingNode['description'],\n            kind: config?.convertExtensions ||\n                node.kind === 'ScalarTypeDefinition' ||\n                existingNode.kind === 'ScalarTypeDefinition'\n                ? 'ScalarTypeDefinition'\n                : 'ScalarTypeExtension',\n            loc: node.loc,\n            directives: mergeDirectives(node.directives, existingNode.directives, config, directives),\n        };\n    }\n    return config?.convertExtensions\n        ? {\n            ...node,\n            kind: Kind.SCALAR_TYPE_DEFINITION,\n        }\n        : node;\n}\n"],"names":[],"mappings":";;AAEO,SAAS,YAAY,MAAM,cAAc,QAAQ,YAAY;AAChE,MAAI,cAAc;AACd,WAAO;AAAA,MACH,MAAM,KAAK;AAAA,MACX,aAAa,KAAK,aAAa,KAAK,aAAa,aAAa;AAAA,MAC9D,MAAM,QAAQ,qBACV,KAAK,SAAS,0BACd,aAAa,SAAS,yBACpB,yBACA;AAAA,MACN,KAAK,KAAK;AAAA,MACV,YAAY,gBAAgB,KAAK,YAAY,aAAa,YAAY,QAAQ,UAAU;AAAA,IACpG;AAAA,EACI;AACA,SAAO,QAAQ,oBACT;AAAA,IACE,GAAG;AAAA,IACH,MAAM,KAAK;AAAA,EACvB,IACU;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/schema-def.js

@@ -0,0 +1,36 @@
+import { mergeDirectives } from "./directives.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+const DEFAULT_OPERATION_TYPE_NAME_MAP = {
+  query: "Query",
+  mutation: "Mutation",
+  subscription: "Subscription"
+};
+function mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {
+  const finalOpNodeList = [];
+  for (const opNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {
+    const opNode = opNodeList.find((n) => n.operation === opNodeType) || existingOpNodeList.find((n) => n.operation === opNodeType);
+    if (opNode) {
+      finalOpNodeList.push(opNode);
+    }
+  }
+  return finalOpNodeList;
+}
+function mergeSchemaDefs(node, existingNode, config, directives) {
+  if (existingNode) {
+    return {
+      kind: node.kind === Kind.SCHEMA_DEFINITION || existingNode.kind === Kind.SCHEMA_DEFINITION ? Kind.SCHEMA_DEFINITION : Kind.SCHEMA_EXTENSION,
+      description: node["description"] || existingNode["description"],
+      directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
+      operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes)
+    };
+  }
+  return config?.convertExtensions ? {
+    ...node,
+    kind: Kind.SCHEMA_DEFINITION
+  } : node;
+}
+export {
+  DEFAULT_OPERATION_TYPE_NAME_MAP,
+  mergeSchemaDefs
+};
+//# sourceMappingURL=schema-def.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/schema-def.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"schema-def.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/schema-def.js"],"sourcesContent":["import { Kind, } from 'graphql';\nimport { mergeDirectives } from './directives.js';\nexport const DEFAULT_OPERATION_TYPE_NAME_MAP = {\n    query: 'Query',\n    mutation: 'Mutation',\n    subscription: 'Subscription',\n};\nfunction mergeOperationTypes(opNodeList = [], existingOpNodeList = []) {\n    const finalOpNodeList = [];\n    for (const opNodeType in DEFAULT_OPERATION_TYPE_NAME_MAP) {\n        const opNode = opNodeList.find(n => n.operation === opNodeType) ||\n            existingOpNodeList.find(n => n.operation === opNodeType);\n        if (opNode) {\n            finalOpNodeList.push(opNode);\n        }\n    }\n    return finalOpNodeList;\n}\nexport function mergeSchemaDefs(node, existingNode, config, directives) {\n    if (existingNode) {\n        return {\n            kind: node.kind === Kind.SCHEMA_DEFINITION || existingNode.kind === Kind.SCHEMA_DEFINITION\n                ? Kind.SCHEMA_DEFINITION\n                : Kind.SCHEMA_EXTENSION,\n            description: node['description'] || existingNode['description'],\n            directives: mergeDirectives(node.directives, existingNode.directives, config, directives),\n            operationTypes: mergeOperationTypes(node.operationTypes, existingNode.operationTypes),\n        };\n    }\n    return (config?.convertExtensions\n        ? {\n            ...node,\n            kind: Kind.SCHEMA_DEFINITION,\n        }\n        : node);\n}\n"],"names":[],"mappings":";;AAEY,MAAC,kCAAkC;AAAA,EAC3C,OAAO;AAAA,EACP,UAAU;AAAA,EACV,cAAc;AAClB;AACA,SAAS,oBAAoB,aAAa,IAAI,qBAAqB,CAAA,GAAI;AACnE,QAAM,kBAAkB,CAAA;AACxB,aAAW,cAAc,iCAAiC;AACtD,UAAM,SAAS,WAAW,KAAK,OAAK,EAAE,cAAc,UAAU,KAC1D,mBAAmB,KAAK,OAAK,EAAE,cAAc,UAAU;AAC3D,QAAI,QAAQ;AACR,sBAAgB,KAAK,MAAM;AAAA,IAC/B;AAAA,EACJ;AACA,SAAO;AACX;AACO,SAAS,gBAAgB,MAAM,cAAc,QAAQ,YAAY;AACpE,MAAI,cAAc;AACd,WAAO;AAAA,MACH,MAAM,KAAK,SAAS,KAAK,qBAAqB,aAAa,SAAS,KAAK,oBACnE,KAAK,oBACL,KAAK;AAAA,MACX,aAAa,KAAK,aAAa,KAAK,aAAa,aAAa;AAAA,MAC9D,YAAY,gBAAgB,KAAK,YAAY,aAAa,YAAY,QAAQ,UAAU;AAAA,MACxF,gBAAgB,oBAAoB,KAAK,gBAAgB,aAAa,cAAc;AAAA,IAChG;AAAA,EACI;AACA,SAAQ,QAAQ,oBACV;AAAA,IACE,GAAG;AAAA,IACH,MAAM,KAAK;AAAA,EACvB,IACU;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/type.js

@@ -0,0 +1,29 @@
+import { mergeDirectives } from "./directives.js";
+import { mergeFields } from "./fields.js";
+import { mergeNamedTypeArray } from "./merge-named-type-array.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+function mergeType(node, existingNode, config, directives) {
+  if (existingNode) {
+    try {
+      return {
+        name: node.name,
+        description: node["description"] || existingNode["description"],
+        kind: config?.convertExtensions || node.kind === "ObjectTypeDefinition" || existingNode.kind === "ObjectTypeDefinition" ? "ObjectTypeDefinition" : "ObjectTypeExtension",
+        loc: node.loc,
+        fields: mergeFields(node, node.fields, existingNode.fields, config, directives),
+        directives: mergeDirectives(node.directives, existingNode.directives, config, directives),
+        interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config)
+      };
+    } catch (e) {
+      throw new Error(`Unable to merge GraphQL type "${node.name.value}": ${e.message}`);
+    }
+  }
+  return config?.convertExtensions ? {
+    ...node,
+    kind: Kind.OBJECT_TYPE_DEFINITION
+  } : node;
+}
+export {
+  mergeType
+};
+//# sourceMappingURL=type.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/type.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/type.js"],"sourcesContent":["import { Kind, } from 'graphql';\nimport { mergeDirectives } from './directives.js';\nimport { mergeFields } from './fields.js';\nimport { mergeNamedTypeArray } from './merge-named-type-array.js';\nexport function mergeType(node, existingNode, config, directives) {\n    if (existingNode) {\n        try {\n            return {\n                name: node.name,\n                description: node['description'] || existingNode['description'],\n                kind: config?.convertExtensions ||\n                    node.kind === 'ObjectTypeDefinition' ||\n                    existingNode.kind === 'ObjectTypeDefinition'\n                    ? 'ObjectTypeDefinition'\n                    : 'ObjectTypeExtension',\n                loc: node.loc,\n                fields: mergeFields(node, node.fields, existingNode.fields, config, directives),\n                directives: mergeDirectives(node.directives, existingNode.directives, config, directives),\n                interfaces: mergeNamedTypeArray(node.interfaces, existingNode.interfaces, config),\n            };\n        }\n        catch (e) {\n            throw new Error(`Unable to merge GraphQL type \"${node.name.value}\": ${e.message}`);\n        }\n    }\n    return config?.convertExtensions\n        ? {\n            ...node,\n            kind: Kind.OBJECT_TYPE_DEFINITION,\n        }\n        : node;\n}\n"],"names":[],"mappings":";;;;AAIO,SAAS,UAAU,MAAM,cAAc,QAAQ,YAAY;AAC9D,MAAI,cAAc;AACd,QAAI;AACA,aAAO;AAAA,QACH,MAAM,KAAK;AAAA,QACX,aAAa,KAAK,aAAa,KAAK,aAAa,aAAa;AAAA,QAC9D,MAAM,QAAQ,qBACV,KAAK,SAAS,0BACd,aAAa,SAAS,yBACpB,yBACA;AAAA,QACN,KAAK,KAAK;AAAA,QACV,QAAQ,YAAY,MAAM,KAAK,QAAQ,aAAa,QAAQ,QAAQ,UAAU;AAAA,QAC9E,YAAY,gBAAgB,KAAK,YAAY,aAAa,YAAY,QAAQ,UAAU;AAAA,QACxF,YAAY,oBAAoB,KAAK,YAAY,aAAa,YAAY,MAAM;AAAA,MAChG;AAAA,IACQ,SACO,GAAG;AACN,YAAM,IAAI,MAAM,iCAAiC,KAAK,KAAK,KAAK,MAAM,EAAE,OAAO,EAAE;AAAA,IACrF;AAAA,EACJ;AACA,SAAO,QAAQ,oBACT;AAAA,IACE,GAAG;AAAA,IACH,MAAM,KAAK;AAAA,EACvB,IACU;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/union.js

@@ -0,0 +1,24 @@
+import { mergeDirectives } from "./directives.js";
+import { mergeNamedTypeArray } from "./merge-named-type-array.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+function mergeUnion(first, second, config, directives) {
+  if (second) {
+    return {
+      name: first.name,
+      description: first["description"] || second["description"],
+      // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility
+      directives: mergeDirectives(first.directives, second.directives, config, directives),
+      kind: config?.convertExtensions || first.kind === "UnionTypeDefinition" || second.kind === "UnionTypeDefinition" ? Kind.UNION_TYPE_DEFINITION : Kind.UNION_TYPE_EXTENSION,
+      loc: first.loc,
+      types: mergeNamedTypeArray(first.types, second.types, config)
+    };
+  }
+  return config?.convertExtensions ? {
+    ...first,
+    kind: Kind.UNION_TYPE_DEFINITION
+  } : first;
+}
+export {
+  mergeUnion
+};
+//# sourceMappingURL=union.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/union.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"union.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/union.js"],"sourcesContent":["import { Kind, } from 'graphql';\nimport { mergeDirectives } from './directives.js';\nimport { mergeNamedTypeArray } from './merge-named-type-array.js';\nexport function mergeUnion(first, second, config, directives) {\n    if (second) {\n        return {\n            name: first.name,\n            description: first['description'] || second['description'],\n            // ConstXNode has been introduced in v16 but it is not compatible with XNode so we do `as any` for backwards compatibility\n            directives: mergeDirectives(first.directives, second.directives, config, directives),\n            kind: config?.convertExtensions ||\n                first.kind === 'UnionTypeDefinition' ||\n                second.kind === 'UnionTypeDefinition'\n                ? Kind.UNION_TYPE_DEFINITION\n                : Kind.UNION_TYPE_EXTENSION,\n            loc: first.loc,\n            types: mergeNamedTypeArray(first.types, second.types, config),\n        };\n    }\n    return config?.convertExtensions\n        ? {\n            ...first,\n            kind: Kind.UNION_TYPE_DEFINITION,\n        }\n        : first;\n}\n"],"names":[],"mappings":";;;AAGO,SAAS,WAAW,OAAO,QAAQ,QAAQ,YAAY;AAC1D,MAAI,QAAQ;AACR,WAAO;AAAA,MACH,MAAM,MAAM;AAAA,MACZ,aAAa,MAAM,aAAa,KAAK,OAAO,aAAa;AAAA;AAAA,MAEzD,YAAY,gBAAgB,MAAM,YAAY,OAAO,YAAY,QAAQ,UAAU;AAAA,MACnF,MAAM,QAAQ,qBACV,MAAM,SAAS,yBACf,OAAO,SAAS,wBACd,KAAK,wBACL,KAAK;AAAA,MACX,KAAK,MAAM;AAAA,MACX,OAAO,oBAAoB,MAAM,OAAO,OAAO,OAAO,MAAM;AAAA,IACxE;AAAA,EACI;AACA,SAAO,QAAQ,oBACT;AAAA,IACE,GAAG;AAAA,IACH,MAAM,KAAK;AAAA,EACvB,IACU;AACV;","x_google_ignoreList":[0]}

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/utils.js

@@ -0,0 +1,67 @@
+import { Source } from "../../../../graphql/language/source.js";
+import { Kind } from "../../../../graphql/language/kinds.js";
+function isStringTypes(types) {
+  return typeof types === "string";
+}
+function isSourceTypes(types) {
+  return types instanceof Source;
+}
+function extractType(type) {
+  let visitedType = type;
+  while (visitedType.kind === Kind.LIST_TYPE || visitedType.kind === "NonNullType") {
+    visitedType = visitedType.type;
+  }
+  return visitedType;
+}
+function isWrappingTypeNode(type) {
+  return type.kind !== Kind.NAMED_TYPE;
+}
+function isListTypeNode(type) {
+  return type.kind === Kind.LIST_TYPE;
+}
+function isNonNullTypeNode(type) {
+  return type.kind === Kind.NON_NULL_TYPE;
+}
+function printTypeNode(type) {
+  if (isListTypeNode(type)) {
+    return `[${printTypeNode(type.type)}]`;
+  }
+  if (isNonNullTypeNode(type)) {
+    return `${printTypeNode(type.type)}!`;
+  }
+  return type.name.value;
+}
+var CompareVal;
+(function(CompareVal2) {
+  CompareVal2[CompareVal2["A_SMALLER_THAN_B"] = -1] = "A_SMALLER_THAN_B";
+  CompareVal2[CompareVal2["A_EQUALS_B"] = 0] = "A_EQUALS_B";
+  CompareVal2[CompareVal2["A_GREATER_THAN_B"] = 1] = "A_GREATER_THAN_B";
+})(CompareVal || (CompareVal = {}));
+function defaultStringComparator(a, b) {
+  if (a == null && b == null) {
+    return CompareVal.A_EQUALS_B;
+  }
+  if (a == null) {
+    return CompareVal.A_SMALLER_THAN_B;
+  }
+  if (b == null) {
+    return CompareVal.A_GREATER_THAN_B;
+  }
+  if (a < b)
+    return CompareVal.A_SMALLER_THAN_B;
+  if (a > b)
+    return CompareVal.A_GREATER_THAN_B;
+  return CompareVal.A_EQUALS_B;
+}
+export {
+  CompareVal,
+  defaultStringComparator,
+  extractType,
+  isListTypeNode,
+  isNonNullTypeNode,
+  isSourceTypes,
+  isStringTypes,
+  isWrappingTypeNode,
+  printTypeNode
+};
+//# sourceMappingURL=utils.js.map

package/dist/node_modules/@graphql-tools/merge/esm/typedefs-mergers/utils.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"utils.js","sources":["../../../../../../node_modules/@graphql-tools/merge/esm/typedefs-mergers/utils.js"],"sourcesContent":["import { Kind, Source } from 'graphql';\nexport function isStringTypes(types) {\n    return typeof types === 'string';\n}\nexport function isSourceTypes(types) {\n    return types instanceof Source;\n}\nexport function extractType(type) {\n    let visitedType = type;\n    while (visitedType.kind === Kind.LIST_TYPE || visitedType.kind === 'NonNullType') {\n        visitedType = visitedType.type;\n    }\n    return visitedType;\n}\nexport function isWrappingTypeNode(type) {\n    return type.kind !== Kind.NAMED_TYPE;\n}\nexport function isListTypeNode(type) {\n    return type.kind === Kind.LIST_TYPE;\n}\nexport function isNonNullTypeNode(type) {\n    return type.kind === Kind.NON_NULL_TYPE;\n}\nexport function printTypeNode(type) {\n    if (isListTypeNode(type)) {\n        return `[${printTypeNode(type.type)}]`;\n    }\n    if (isNonNullTypeNode(type)) {\n        return `${printTypeNode(type.type)}!`;\n    }\n    return type.name.value;\n}\nexport var CompareVal;\n(function (CompareVal) {\n    CompareVal[CompareVal[\"A_SMALLER_THAN_B\"] = -1] = \"A_SMALLER_THAN_B\";\n    CompareVal[CompareVal[\"A_EQUALS_B\"] = 0] = \"A_EQUALS_B\";\n    CompareVal[CompareVal[\"A_GREATER_THAN_B\"] = 1] = \"A_GREATER_THAN_B\";\n})(CompareVal || (CompareVal = {}));\nexport function defaultStringComparator(a, b) {\n    if (a == null && b == null) {\n        return CompareVal.A_EQUALS_B;\n    }\n    if (a == null) {\n        return CompareVal.A_SMALLER_THAN_B;\n    }\n    if (b == null) {\n        return CompareVal.A_GREATER_THAN_B;\n    }\n    if (a < b)\n        return CompareVal.A_SMALLER_THAN_B;\n    if (a > b)\n        return CompareVal.A_GREATER_THAN_B;\n    return CompareVal.A_EQUALS_B;\n}\n"],"names":["CompareVal"],"mappings":";;AACO,SAAS,cAAc,OAAO;AACjC,SAAO,OAAO,UAAU;AAC5B;AACO,SAAS,cAAc,OAAO;AACjC,SAAO,iBAAiB;AAC5B;AACO,SAAS,YAAY,MAAM;AAC9B,MAAI,cAAc;AAClB,SAAO,YAAY,SAAS,KAAK,aAAa,YAAY,SAAS,eAAe;AAC9E,kBAAc,YAAY;AAAA,EAC9B;AACA,SAAO;AACX;AACO,SAAS,mBAAmB,MAAM;AACrC,SAAO,KAAK,SAAS,KAAK;AAC9B;AACO,SAAS,eAAe,MAAM;AACjC,SAAO,KAAK,SAAS,KAAK;AAC9B;AACO,SAAS,kBAAkB,MAAM;AACpC,SAAO,KAAK,SAAS,KAAK;AAC9B;AACO,SAAS,cAAc,MAAM;AAChC,MAAI,eAAe,IAAI,GAAG;AACtB,WAAO,IAAI,cAAc,KAAK,IAAI,CAAC;AAAA,EACvC;AACA,MAAI,kBAAkB,IAAI,GAAG;AACzB,WAAO,GAAG,cAAc,KAAK,IAAI,CAAC;AAAA,EACtC;AACA,SAAO,KAAK,KAAK;AACrB;AACU,IAAC;AAAA,CACV,SAAUA,aAAY;AACnB,EAAAA,YAAWA,YAAW,kBAAkB,IAAI,EAAE,IAAI;AAClD,EAAAA,YAAWA,YAAW,YAAY,IAAI,CAAC,IAAI;AAC3C,EAAAA,YAAWA,YAAW,kBAAkB,IAAI,CAAC,IAAI;AACrD,GAAG,eAAe,aAAa,CAAA,EAAG;AAC3B,SAAS,wBAAwB,GAAG,GAAG;AAC1C,MAAI,KAAK,QAAQ,KAAK,MAAM;AACxB,WAAO,WAAW;AAAA,EACtB;AACA,MAAI,KAAK,MAAM;AACX,WAAO,WAAW;AAAA,EACtB;AACA,MAAI,KAAK,MAAM;AACX,WAAO,WAAW;AAAA,EACtB;AACA,MAAI,IAAI;AACJ,WAAO,WAAW;AACtB,MAAI,IAAI;AACJ,WAAO,WAAW;AACtB,SAAO,WAAW;AACtB;","x_google_ignoreList":[0]}