@graphql-tools/utils 8.7.0 → 8.8.0-alpha-b76ec274.0

package/cjs/get-directives.js

@@ -0,0 +1,103 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getDirective = exports.getDirectives = exports.getDirectiveInExtensions = exports.getDirectivesInExtensions = void 0;
+const getArgumentValues_js_1 = require("./getArgumentValues.js");
+function getDirectivesInExtensions(node, pathToDirectivesInExtensions = ['directives']) {
+    return pathToDirectivesInExtensions.reduce((acc, pathSegment) => (acc == null ? acc : acc[pathSegment]), node === null || node === void 0 ? void 0 : node.extensions);
+}
+exports.getDirectivesInExtensions = getDirectivesInExtensions;
+function _getDirectiveInExtensions(directivesInExtensions, directiveName) {
+    const directiveInExtensions = directivesInExtensions.filter(directiveAnnotation => directiveAnnotation.name === directiveName);
+    if (!directiveInExtensions.length) {
+        return undefined;
+    }
+    return directiveInExtensions.map(directive => { var _a; return (_a = directive.args) !== null && _a !== void 0 ? _a : {}; });
+}
+function getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions = ['directives']) {
+    const directivesInExtensions = pathToDirectivesInExtensions.reduce((acc, pathSegment) => (acc == null ? acc : acc[pathSegment]), node === null || node === void 0 ? void 0 : node.extensions);
+    if (directivesInExtensions === undefined) {
+        return undefined;
+    }
+    if (Array.isArray(directivesInExtensions)) {
+        return _getDirectiveInExtensions(directivesInExtensions, directiveName);
+    }
+    // Support condensed format by converting to longer format
+    // The condensed format does not preserve ordering of directives when  repeatable directives are used.
+    // See https://github.com/ardatan/graphql-tools/issues/2534
+    const reformattedDirectivesInExtensions = [];
+    for (const [name, argsOrArrayOfArgs] of Object.entries(directivesInExtensions)) {
+        if (Array.isArray(argsOrArrayOfArgs)) {
+            for (const args of argsOrArrayOfArgs) {
+                reformattedDirectivesInExtensions.push({ name, args });
+            }
+        }
+        else {
+            reformattedDirectivesInExtensions.push({ name, args: argsOrArrayOfArgs });
+        }
+    }
+    return _getDirectiveInExtensions(reformattedDirectivesInExtensions, directiveName);
+}
+exports.getDirectiveInExtensions = getDirectiveInExtensions;
+function getDirectives(schema, node, pathToDirectivesInExtensions = ['directives']) {
+    const directivesInExtensions = getDirectivesInExtensions(node, pathToDirectivesInExtensions);
+    if (directivesInExtensions != null && directivesInExtensions.length > 0) {
+        return directivesInExtensions;
+    }
+    const schemaDirectives = schema && schema.getDirectives ? schema.getDirectives() : [];
+    const schemaDirectiveMap = schemaDirectives.reduce((schemaDirectiveMap, schemaDirective) => {
+        schemaDirectiveMap[schemaDirective.name] = schemaDirective;
+        return schemaDirectiveMap;
+    }, {});
+    let astNodes = [];
+    if (node.astNode) {
+        astNodes.push(node.astNode);
+    }
+    if ('extensionASTNodes' in node && node.extensionASTNodes) {
+        astNodes = [...astNodes, ...node.extensionASTNodes];
+    }
+    const result = [];
+    for (const astNode of astNodes) {
+        if (astNode.directives) {
+            for (const directiveNode of astNode.directives) {
+                const schemaDirective = schemaDirectiveMap[directiveNode.name.value];
+                if (schemaDirective) {
+                    result.push({ name: directiveNode.name.value, args: (0, getArgumentValues_js_1.getArgumentValues)(schemaDirective, directiveNode) });
+                }
+            }
+        }
+    }
+    return result;
+}
+exports.getDirectives = getDirectives;
+function getDirective(schema, node, directiveName, pathToDirectivesInExtensions = ['directives']) {
+    const directiveInExtensions = getDirectiveInExtensions(node, directiveName, pathToDirectivesInExtensions);
+    if (directiveInExtensions != null) {
+        return directiveInExtensions;
+    }
+    const schemaDirective = schema && schema.getDirective ? schema.getDirective(directiveName) : undefined;
+    if (schemaDirective == null) {
+        return undefined;
+    }
+    let astNodes = [];
+    if (node.astNode) {
+        astNodes.push(node.astNode);
+    }
+    if ('extensionASTNodes' in node && node.extensionASTNodes) {
+        astNodes = [...astNodes, ...node.extensionASTNodes];
+    }
+    const result = [];
+    for (const astNode of astNodes) {
+        if (astNode.directives) {
+            for (const directiveNode of astNode.directives) {
+                if (directiveNode.name.value === directiveName) {
+                    result.push((0, getArgumentValues_js_1.getArgumentValues)(schemaDirective, directiveNode));
+                }
+            }
+        }
+    }
+    if (!result.length) {
+        return undefined;
+    }
+    return result;
+}
+exports.getDirective = getDirective;

package/cjs/get-fields-with-directives.js

@@ -0,0 +1,52 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getFieldsWithDirectives = void 0;
+const graphql_1 = require("graphql");
+function parseDirectiveValue(value) {
+    switch (value.kind) {
+        case graphql_1.Kind.INT:
+            return parseInt(value.value);
+        case graphql_1.Kind.FLOAT:
+            return parseFloat(value.value);
+        case graphql_1.Kind.BOOLEAN:
+            return Boolean(value.value);
+        case graphql_1.Kind.STRING:
+        case graphql_1.Kind.ENUM:
+            return value.value;
+        case graphql_1.Kind.LIST:
+            return value.values.map(v => parseDirectiveValue(v));
+        case graphql_1.Kind.OBJECT:
+            return value.fields.reduce((prev, v) => ({ ...prev, [v.name.value]: parseDirectiveValue(v.value) }), {});
+        case graphql_1.Kind.NULL:
+            return null;
+        default:
+            return null;
+    }
+}
+function getFieldsWithDirectives(documentNode, options = {}) {
+    const result = {};
+    let selected = ['ObjectTypeDefinition', 'ObjectTypeExtension'];
+    if (options.includeInputTypes) {
+        selected = [...selected, 'InputObjectTypeDefinition', 'InputObjectTypeExtension'];
+    }
+    const allTypes = documentNode.definitions.filter(obj => selected.includes(obj.kind));
+    for (const type of allTypes) {
+        const typeName = type.name.value;
+        if (type.fields == null) {
+            continue;
+        }
+        for (const field of type.fields) {
+            if (field.directives && field.directives.length > 0) {
+                const fieldName = field.name.value;
+                const key = `${typeName}.${fieldName}`;
+                const directives = field.directives.map(d => ({
+                    name: d.name.value,
+                    args: (d.arguments || []).reduce((prev, arg) => ({ ...prev, [arg.name.value]: parseDirectiveValue(arg.value) }), {}),
+                }));
+                result[key] = directives;
+            }
+        }
+    }
+    return result;
+}
+exports.getFieldsWithDirectives = getFieldsWithDirectives;

package/cjs/get-implementing-types.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getImplementingTypes = void 0;
+const graphql_1 = require("graphql");
+function getImplementingTypes(interfaceName, schema) {
+    const allTypesMap = schema.getTypeMap();
+    const result = [];
+    for (const graphqlTypeName in allTypesMap) {
+        const graphqlType = allTypesMap[graphqlTypeName];
+        if ((0, graphql_1.isObjectType)(graphqlType)) {
+            const allInterfaces = graphqlType.getInterfaces();
+            if (allInterfaces.find(int => int.name === interfaceName)) {
+                result.push(graphqlType.name);
+            }
+        }
+    }
+    return result;
+}
+exports.getImplementingTypes = getImplementingTypes;

package/cjs/getArgumentValues.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getArgumentValues = void 0;
+const graphql_1 = require("graphql");
+const errors_js_1 = require("./errors.js");
+const inspect_js_1 = require("./inspect.js");
+/**
+ * Prepares an object map of argument values given a list of argument
+ * definitions and list of argument AST nodes.
+ *
+ * Note: The returned value is a plain Object with a prototype, since it is
+ * exposed to user code. Care should be taken to not pull values from the
+ * Object prototype.
+ */
+function getArgumentValues(def, node, variableValues = {}) {
+    var _a;
+    const variableMap = Object.entries(variableValues).reduce((prev, [key, value]) => ({
+        ...prev,
+        [key]: value,
+    }), {});
+    const coercedValues = {};
+    const argumentNodes = (_a = node.arguments) !== null && _a !== void 0 ? _a : [];
+    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 !== undefined) {
+                coercedValues[name] = defaultValue;
+            }
+            else if ((0, graphql_1.isNonNullType)(argType)) {
+                throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of required type "${(0, inspect_js_1.inspect)(argType)}" ` + 'was not provided.', {
+                    nodes: [node],
+                });
+            }
+            continue;
+        }
+        const valueNode = argumentNode.value;
+        let isNull = valueNode.kind === graphql_1.Kind.NULL;
+        if (valueNode.kind === graphql_1.Kind.VARIABLE) {
+            const variableName = valueNode.name.value;
+            if (variableValues == null || variableMap[variableName] == null) {
+                if (defaultValue !== undefined) {
+                    coercedValues[name] = defaultValue;
+                }
+                else if ((0, graphql_1.isNonNullType)(argType)) {
+                    throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of required type "${(0, inspect_js_1.inspect)(argType)}" ` +
+                        `was provided the variable "$${variableName}" which was not provided a runtime value.`, {
+                        nodes: [valueNode],
+                    });
+                }
+                continue;
+            }
+            isNull = variableValues[variableName] == null;
+        }
+        if (isNull && (0, graphql_1.isNonNullType)(argType)) {
+            throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" of non-null type "${(0, inspect_js_1.inspect)(argType)}" ` + 'must not be null.', {
+                nodes: [valueNode],
+            });
+        }
+        const coercedValue = (0, graphql_1.valueFromAST)(valueNode, argType, variableValues);
+        if (coercedValue === undefined) {
+            // Note: ValuesOfCorrectTypeRule validation should catch this before
+            // execution. This is a runtime check to ensure execution does not
+            // continue with an invalid argument value.
+            throw (0, errors_js_1.createGraphQLError)(`Argument "${name}" has invalid value ${(0, graphql_1.print)(valueNode)}.`, {
+                nodes: [valueNode],
+            });
+        }
+        coercedValues[name] = coercedValue;
+    }
+    return coercedValues;
+}
+exports.getArgumentValues = getArgumentValues;

package/cjs/getObjectTypeFromTypeMap.js

@@ -0,0 +1,13 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getObjectTypeFromTypeMap = void 0;
+const graphql_1 = require("graphql");
+function getObjectTypeFromTypeMap(typeMap, type) {
+    if (type) {
+        const maybeObjectType = typeMap[type.name];
+        if ((0, graphql_1.isObjectType)(maybeObjectType)) {
+            return maybeObjectType;
+        }
+    }
+}
+exports.getObjectTypeFromTypeMap = getObjectTypeFromTypeMap;

package/cjs/getOperationASTFromRequest.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getOperationASTFromRequest = exports.getOperationASTFromDocument = void 0;
+const graphql_1 = require("graphql");
+const memoize_js_1 = require("./memoize.js");
+function getOperationASTFromDocument(documentNode, operationName) {
+    const doc = (0, graphql_1.getOperationAST)(documentNode, operationName);
+    if (!doc) {
+        throw new Error(`Cannot infer operation ${operationName || ''}`);
+    }
+    return doc;
+}
+exports.getOperationASTFromDocument = getOperationASTFromDocument;
+exports.getOperationASTFromRequest = (0, memoize_js_1.memoize1)(function getOperationASTFromRequest(request) {
+    return getOperationASTFromDocument(request.document, request.operationName);
+});

package/cjs/getResolversFromSchema.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResolversFromSchema = void 0;
+const graphql_1 = require("graphql");
+function getResolversFromSchema(schema, 
+// Include default merged resolvers
+includeDefaultMergedResolver) {
+    var _a, _b;
+    const resolvers = Object.create(null);
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        if (!typeName.startsWith('__')) {
+            const type = typeMap[typeName];
+            if ((0, graphql_1.isScalarType)(type)) {
+                if (!(0, graphql_1.isSpecifiedScalarType)(type)) {
+                    const config = type.toConfig();
+                    delete config.astNode; // avoid AST duplication elsewhere
+                    resolvers[typeName] = new graphql_1.GraphQLScalarType(config);
+                }
+            }
+            else if ((0, graphql_1.isEnumType)(type)) {
+                resolvers[typeName] = {};
+                const values = type.getValues();
+                for (const value of values) {
+                    resolvers[typeName][value.name] = value.value;
+                }
+            }
+            else if ((0, graphql_1.isInterfaceType)(type)) {
+                if (type.resolveType != null) {
+                    resolvers[typeName] = {
+                        __resolveType: type.resolveType,
+                    };
+                }
+            }
+            else if ((0, graphql_1.isUnionType)(type)) {
+                if (type.resolveType != null) {
+                    resolvers[typeName] = {
+                        __resolveType: type.resolveType,
+                    };
+                }
+            }
+            else if ((0, graphql_1.isObjectType)(type)) {
+                resolvers[typeName] = {};
+                if (type.isTypeOf != null) {
+                    resolvers[typeName].__isTypeOf = type.isTypeOf;
+                }
+                const fields = type.getFields();
+                for (const fieldName in fields) {
+                    const field = fields[fieldName];
+                    if (field.subscribe != null) {
+                        resolvers[typeName][fieldName] = resolvers[typeName][fieldName] || {};
+                        resolvers[typeName][fieldName].subscribe = field.subscribe;
+                    }
+                    if (field.resolve != null && ((_a = field.resolve) === null || _a === void 0 ? void 0 : _a.name) !== 'defaultFieldResolver') {
+                        switch ((_b = field.resolve) === null || _b === void 0 ? void 0 : _b.name) {
+                            case 'defaultMergedResolver':
+                                if (!includeDefaultMergedResolver) {
+                                    continue;
+                                }
+                                break;
+                            case 'defaultFieldResolver':
+                                continue;
+                        }
+                        resolvers[typeName][fieldName] = resolvers[typeName][fieldName] || {};
+                        resolvers[typeName][fieldName].resolve = field.resolve;
+                    }
+                }
+            }
+        }
+    }
+    return resolvers;
+}
+exports.getResolversFromSchema = getResolversFromSchema;

package/cjs/getResponseKeyFromInfo.js

@@ -0,0 +1,12 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getResponseKeyFromInfo = void 0;
+/**
+ * Get the key under which the result of this resolver will be placed in the response JSON. Basically, just
+ * resolves aliases.
+ * @param info The info argument to the resolver.
+ */
+function getResponseKeyFromInfo(info) {
+    return info.fieldNodes[0].alias != null ? info.fieldNodes[0].alias.value : info.fieldName;
+}
+exports.getResponseKeyFromInfo = getResponseKeyFromInfo;

package/cjs/heal.js

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

package/cjs/helpers.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.assertSome = exports.isSome = exports.compareNodes = exports.nodeToString = exports.compareStrings = exports.isValidPath = exports.isDocumentString = exports.asArray = void 0;
+const graphql_1 = require("graphql");
+const asArray = (fns) => (Array.isArray(fns) ? fns : fns ? [fns] : []);
+exports.asArray = asArray;
+const invalidDocRegex = /\.[a-z0-9]+$/i;
+function isDocumentString(str) {
+    if (typeof str !== 'string') {
+        return false;
+    }
+    // XXX: is-valid-path or is-glob treat SDL as a valid path
+    // (`scalar Date` for example)
+    // this why checking the extension is fast enough
+    // and prevent from parsing the string in order to find out
+    // if the string is a SDL
+    if (invalidDocRegex.test(str)) {
+        return false;
+    }
+    try {
+        (0, graphql_1.parse)(str);
+        return true;
+    }
+    catch (e) { }
+    return false;
+}
+exports.isDocumentString = isDocumentString;
+const invalidPathRegex = /[‘“!%&^<=>`]/;
+function isValidPath(str) {
+    return typeof str === 'string' && !invalidPathRegex.test(str);
+}
+exports.isValidPath = isValidPath;
+function compareStrings(a, b) {
+    if (String(a) < String(b)) {
+        return -1;
+    }
+    if (String(a) > String(b)) {
+        return 1;
+    }
+    return 0;
+}
+exports.compareStrings = compareStrings;
+function nodeToString(a) {
+    var _a, _b;
+    let name;
+    if ('alias' in a) {
+        name = (_a = a.alias) === null || _a === void 0 ? void 0 : _a.value;
+    }
+    if (name == null && 'name' in a) {
+        name = (_b = a.name) === null || _b === void 0 ? void 0 : _b.value;
+    }
+    if (name == null) {
+        name = a.kind;
+    }
+    return name;
+}
+exports.nodeToString = nodeToString;
+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);
+}
+exports.compareNodes = compareNodes;
+function isSome(input) {
+    return input != null;
+}
+exports.isSome = isSome;
+function assertSome(input, message = 'Value should be something') {
+    if (input == null) {
+        throw new Error(message);
+    }
+}
+exports.assertSome = assertSome;

package/cjs/implementsAbstractType.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.implementsAbstractType = void 0;
+const graphql_1 = require("graphql");
+function implementsAbstractType(schema, typeA, typeB) {
+    if (typeB == null || typeA == null) {
+        return false;
+    }
+    else if (typeA === typeB) {
+        return true;
+    }
+    else if ((0, graphql_1.isCompositeType)(typeA) && (0, graphql_1.isCompositeType)(typeB)) {
+        return (0, graphql_1.doTypesOverlap)(schema, typeA, typeB);
+    }
+    return false;
+}
+exports.implementsAbstractType = implementsAbstractType;