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

package/cjs/renameType.js

@@ -0,0 +1,152 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.renameType = void 0;
+const graphql_1 = require("graphql");
+function renameType(type, newTypeName) {
+    if ((0, graphql_1.isObjectType)(type)) {
+        return new graphql_1.GraphQLObjectType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if ((0, graphql_1.isInterfaceType)(type)) {
+        return new graphql_1.GraphQLInterfaceType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if ((0, graphql_1.isUnionType)(type)) {
+        return new graphql_1.GraphQLUnionType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if ((0, graphql_1.isInputObjectType)(type)) {
+        return new graphql_1.GraphQLInputObjectType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if ((0, graphql_1.isEnumType)(type)) {
+        return new graphql_1.GraphQLEnumType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    else if ((0, graphql_1.isScalarType)(type)) {
+        return new graphql_1.GraphQLScalarType({
+            ...type.toConfig(),
+            name: newTypeName,
+            astNode: type.astNode == null
+                ? type.astNode
+                : {
+                    ...type.astNode,
+                    name: {
+                        ...type.astNode.name,
+                        value: newTypeName,
+                    },
+                },
+            extensionASTNodes: type.extensionASTNodes == null
+                ? type.extensionASTNodes
+                : type.extensionASTNodes.map(node => ({
+                    ...node,
+                    name: {
+                        ...node.name,
+                        value: newTypeName,
+                    },
+                })),
+        });
+    }
+    throw new Error(`Unknown type ${type}.`);
+}
+exports.renameType = renameType;

package/cjs/rewire.js

@@ -0,0 +1,159 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rewireTypes = void 0;
+const graphql_1 = require("graphql");
+const stub_js_1 = require("./stub.js");
+function rewireTypes(originalTypeMap, directives) {
+    const referenceTypeMap = Object.create(null);
+    for (const typeName in originalTypeMap) {
+        referenceTypeMap[typeName] = originalTypeMap[typeName];
+    }
+    const newTypeMap = Object.create(null);
+    for (const typeName in referenceTypeMap) {
+        const namedType = referenceTypeMap[typeName];
+        if (namedType == null || typeName.startsWith('__')) {
+            continue;
+        }
+        const newName = namedType.name;
+        if (newName.startsWith('__')) {
+            continue;
+        }
+        if (newTypeMap[newName] != null) {
+            throw new Error(`Duplicate schema type name ${newName}`);
+        }
+        newTypeMap[newName] = namedType;
+    }
+    for (const typeName in newTypeMap) {
+        newTypeMap[typeName] = rewireNamedType(newTypeMap[typeName]);
+    }
+    const newDirectives = directives.map(directive => rewireDirective(directive));
+    return {
+        typeMap: newTypeMap,
+        directives: newDirectives,
+    };
+    function rewireDirective(directive) {
+        if ((0, graphql_1.isSpecifiedDirective)(directive)) {
+            return directive;
+        }
+        const directiveConfig = directive.toConfig();
+        directiveConfig.args = rewireArgs(directiveConfig.args);
+        return new graphql_1.GraphQLDirective(directiveConfig);
+    }
+    function rewireArgs(args) {
+        const rewiredArgs = {};
+        for (const argName in args) {
+            const arg = args[argName];
+            const rewiredArgType = rewireType(arg.type);
+            if (rewiredArgType != null) {
+                arg.type = rewiredArgType;
+                rewiredArgs[argName] = arg;
+            }
+        }
+        return rewiredArgs;
+    }
+    function rewireNamedType(type) {
+        if ((0, graphql_1.isObjectType)(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireFields(config.fields),
+                interfaces: () => rewireNamedTypes(config.interfaces),
+            };
+            return new graphql_1.GraphQLObjectType(newConfig);
+        }
+        else if ((0, graphql_1.isInterfaceType)(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireFields(config.fields),
+            };
+            if ('interfaces' in newConfig) {
+                newConfig.interfaces = () => rewireNamedTypes(config.interfaces);
+            }
+            return new graphql_1.GraphQLInterfaceType(newConfig);
+        }
+        else if ((0, graphql_1.isUnionType)(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                types: () => rewireNamedTypes(config.types),
+            };
+            return new graphql_1.GraphQLUnionType(newConfig);
+        }
+        else if ((0, graphql_1.isInputObjectType)(type)) {
+            const config = type.toConfig();
+            const newConfig = {
+                ...config,
+                fields: () => rewireInputFields(config.fields),
+            };
+            return new graphql_1.GraphQLInputObjectType(newConfig);
+        }
+        else if ((0, graphql_1.isEnumType)(type)) {
+            const enumConfig = type.toConfig();
+            return new graphql_1.GraphQLEnumType(enumConfig);
+        }
+        else if ((0, graphql_1.isScalarType)(type)) {
+            if ((0, graphql_1.isSpecifiedScalarType)(type)) {
+                return type;
+            }
+            const scalarConfig = type.toConfig();
+            return new graphql_1.GraphQLScalarType(scalarConfig);
+        }
+        throw new Error(`Unexpected schema type: ${type}`);
+    }
+    function rewireFields(fields) {
+        const rewiredFields = {};
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            const rewiredFieldType = rewireType(field.type);
+            if (rewiredFieldType != null && field.args) {
+                field.type = rewiredFieldType;
+                field.args = rewireArgs(field.args);
+                rewiredFields[fieldName] = field;
+            }
+        }
+        return rewiredFields;
+    }
+    function rewireInputFields(fields) {
+        const rewiredFields = {};
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            const rewiredFieldType = rewireType(field.type);
+            if (rewiredFieldType != null) {
+                field.type = rewiredFieldType;
+                rewiredFields[fieldName] = field;
+            }
+        }
+        return rewiredFields;
+    }
+    function rewireNamedTypes(namedTypes) {
+        const rewiredTypes = [];
+        for (const namedType of namedTypes) {
+            const rewiredType = rewireType(namedType);
+            if (rewiredType != null) {
+                rewiredTypes.push(rewiredType);
+            }
+        }
+        return rewiredTypes;
+    }
+    function rewireType(type) {
+        if ((0, graphql_1.isListType)(type)) {
+            const rewiredType = rewireType(type.ofType);
+            return rewiredType != null ? new graphql_1.GraphQLList(rewiredType) : null;
+        }
+        else if ((0, graphql_1.isNonNullType)(type)) {
+            const rewiredType = rewireType(type.ofType);
+            return rewiredType != null ? new graphql_1.GraphQLNonNull(rewiredType) : null;
+        }
+        else if ((0, graphql_1.isNamedType)(type)) {
+            let rewiredType = referenceTypeMap[type.name];
+            if (rewiredType === undefined) {
+                rewiredType = (0, stub_js_1.isNamedStub)(type) ? (0, stub_js_1.getBuiltInForStub)(type) : rewireNamedType(type);
+                newTypeMap[rewiredType.name] = referenceTypeMap[type.name] = rewiredType;
+            }
+            return rewiredType != null ? newTypeMap[rewiredType.name] : null;
+        }
+        return null;
+    }
+}
+exports.rewireTypes = rewireTypes;

package/cjs/rootTypes.js

@@ -0,0 +1,37 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getRootTypeMap = exports.getRootTypes = exports.getRootTypeNames = exports.getDefinedRootType = void 0;
+const memoize_js_1 = require("./memoize.js");
+function getDefinedRootType(schema, operation) {
+    const rootTypeMap = (0, exports.getRootTypeMap)(schema);
+    const rootType = rootTypeMap.get(operation);
+    if (rootType == null) {
+        throw new Error(`Root type for operation "${operation}" not defined by the given schema.`);
+    }
+    return rootType;
+}
+exports.getDefinedRootType = getDefinedRootType;
+exports.getRootTypeNames = (0, memoize_js_1.memoize1)(function getRootTypeNames(schema) {
+    const rootTypes = (0, exports.getRootTypes)(schema);
+    return new Set([...rootTypes].map(type => type.name));
+});
+exports.getRootTypes = (0, memoize_js_1.memoize1)(function getRootTypes(schema) {
+    const rootTypeMap = (0, exports.getRootTypeMap)(schema);
+    return new Set(rootTypeMap.values());
+});
+exports.getRootTypeMap = (0, memoize_js_1.memoize1)(function getRootTypeMap(schema) {
+    const rootTypeMap = new Map();
+    const queryType = schema.getQueryType();
+    if (queryType) {
+        rootTypeMap.set('query', queryType);
+    }
+    const mutationType = schema.getMutationType();
+    if (mutationType) {
+        rootTypeMap.set('mutation', mutationType);
+    }
+    const subscriptionType = schema.getSubscriptionType();
+    if (subscriptionType) {
+        rootTypeMap.set('subscription', subscriptionType);
+    }
+    return rootTypeMap;
+});

package/cjs/selectionSets.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseSelectionSet = void 0;
+const graphql_1 = require("graphql");
+function parseSelectionSet(selectionSet, options) {
+    const query = (0, graphql_1.parse)(selectionSet, options).definitions[0];
+    return query.selectionSet;
+}
+exports.parseSelectionSet = parseSelectionSet;

package/cjs/stub.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getBuiltInForStub = exports.isNamedStub = exports.createStub = exports.createNamedStub = void 0;
+const graphql_1 = require("graphql");
+function createNamedStub(name, type) {
+    let constructor;
+    if (type === 'object') {
+        constructor = graphql_1.GraphQLObjectType;
+    }
+    else if (type === 'interface') {
+        constructor = graphql_1.GraphQLInterfaceType;
+    }
+    else {
+        constructor = graphql_1.GraphQLInputObjectType;
+    }
+    return new constructor({
+        name,
+        fields: {
+            _fake: {
+                type: graphql_1.GraphQLString,
+            },
+        },
+    });
+}
+exports.createNamedStub = createNamedStub;
+function createStub(node, type) {
+    switch (node.kind) {
+        case graphql_1.Kind.LIST_TYPE:
+            return new graphql_1.GraphQLList(createStub(node.type, type));
+        case graphql_1.Kind.NON_NULL_TYPE:
+            return new graphql_1.GraphQLNonNull(createStub(node.type, type));
+        default:
+            if (type === 'output') {
+                return createNamedStub(node.name.value, 'object');
+            }
+            return createNamedStub(node.name.value, 'input');
+    }
+}
+exports.createStub = createStub;
+function isNamedStub(type) {
+    if ('getFields' in type) {
+        const fields = type.getFields();
+        // eslint-disable-next-line no-unreachable-loop
+        for (const fieldName in fields) {
+            const field = fields[fieldName];
+            return field.name === '_fake';
+        }
+    }
+    return false;
+}
+exports.isNamedStub = isNamedStub;
+function getBuiltInForStub(type) {
+    switch (type.name) {
+        case graphql_1.GraphQLInt.name:
+            return graphql_1.GraphQLInt;
+        case graphql_1.GraphQLFloat.name:
+            return graphql_1.GraphQLFloat;
+        case graphql_1.GraphQLString.name:
+            return graphql_1.GraphQLString;
+        case graphql_1.GraphQLBoolean.name:
+            return graphql_1.GraphQLBoolean;
+        case graphql_1.GraphQLID.name:
+            return graphql_1.GraphQLID;
+        default:
+            return type;
+    }
+}
+exports.getBuiltInForStub = getBuiltInForStub;

package/cjs/transformInputValue.js

@@ -0,0 +1,55 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseInputValueLiteral = exports.parseInputValue = exports.serializeInputValue = exports.transformInputValue = void 0;
+const graphql_1 = require("graphql");
+function transformInputValue(type, value, inputLeafValueTransformer = null, inputObjectValueTransformer = null) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = (0, graphql_1.getNullableType)(type);
+    if ((0, graphql_1.isLeafType)(nullableType)) {
+        return inputLeafValueTransformer != null ? inputLeafValueTransformer(nullableType, value) : value;
+    }
+    else if ((0, graphql_1.isListType)(nullableType)) {
+        return value.map((listMember) => transformInputValue(nullableType.ofType, listMember, inputLeafValueTransformer, inputObjectValueTransformer));
+    }
+    else if ((0, graphql_1.isInputObjectType)(nullableType)) {
+        const fields = nullableType.getFields();
+        const newValue = {};
+        for (const key in value) {
+            const field = fields[key];
+            if (field != null) {
+                newValue[key] = transformInputValue(field.type, value[key], inputLeafValueTransformer, inputObjectValueTransformer);
+            }
+        }
+        return inputObjectValueTransformer != null ? inputObjectValueTransformer(nullableType, newValue) : newValue;
+    }
+    // unreachable, no other possible return value
+}
+exports.transformInputValue = transformInputValue;
+function serializeInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => {
+        try {
+            return t.serialize(v);
+        }
+        catch (_a) {
+            return v;
+        }
+    });
+}
+exports.serializeInputValue = serializeInputValue;
+function parseInputValue(type, value) {
+    return transformInputValue(type, value, (t, v) => {
+        try {
+            return t.parseValue(v);
+        }
+        catch (_a) {
+            return v;
+        }
+    });
+}
+exports.parseInputValue = parseInputValue;
+function parseInputValueLiteral(type, value) {
+    return transformInputValue(type, value, (t, v) => t.parseLiteral(v, {}));
+}
+exports.parseInputValueLiteral = parseInputValueLiteral;

package/cjs/types.js

@@ -0,0 +1,27 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DirectiveLocation = void 0;
+var DirectiveLocation;
+(function (DirectiveLocation) {
+    /** Request Definitions */
+    DirectiveLocation["QUERY"] = "QUERY";
+    DirectiveLocation["MUTATION"] = "MUTATION";
+    DirectiveLocation["SUBSCRIPTION"] = "SUBSCRIPTION";
+    DirectiveLocation["FIELD"] = "FIELD";
+    DirectiveLocation["FRAGMENT_DEFINITION"] = "FRAGMENT_DEFINITION";
+    DirectiveLocation["FRAGMENT_SPREAD"] = "FRAGMENT_SPREAD";
+    DirectiveLocation["INLINE_FRAGMENT"] = "INLINE_FRAGMENT";
+    DirectiveLocation["VARIABLE_DEFINITION"] = "VARIABLE_DEFINITION";
+    /** Type System Definitions */
+    DirectiveLocation["SCHEMA"] = "SCHEMA";
+    DirectiveLocation["SCALAR"] = "SCALAR";
+    DirectiveLocation["OBJECT"] = "OBJECT";
+    DirectiveLocation["FIELD_DEFINITION"] = "FIELD_DEFINITION";
+    DirectiveLocation["ARGUMENT_DEFINITION"] = "ARGUMENT_DEFINITION";
+    DirectiveLocation["INTERFACE"] = "INTERFACE";
+    DirectiveLocation["UNION"] = "UNION";
+    DirectiveLocation["ENUM"] = "ENUM";
+    DirectiveLocation["ENUM_VALUE"] = "ENUM_VALUE";
+    DirectiveLocation["INPUT_OBJECT"] = "INPUT_OBJECT";
+    DirectiveLocation["INPUT_FIELD_DEFINITION"] = "INPUT_FIELD_DEFINITION";
+})(DirectiveLocation = exports.DirectiveLocation || (exports.DirectiveLocation = {}));

package/cjs/updateArgument.js

@@ -0,0 +1,54 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createVariableNameGenerator = exports.updateArgument = void 0;
+const graphql_1 = require("graphql");
+const astFromType_js_1 = require("./astFromType.js");
+function updateArgument(argumentNodes, variableDefinitionsMap, variableValues, argName, varName, type, value) {
+    argumentNodes[argName] = {
+        kind: graphql_1.Kind.ARGUMENT,
+        name: {
+            kind: graphql_1.Kind.NAME,
+            value: argName,
+        },
+        value: {
+            kind: graphql_1.Kind.VARIABLE,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: varName,
+            },
+        },
+    };
+    variableDefinitionsMap[varName] = {
+        kind: graphql_1.Kind.VARIABLE_DEFINITION,
+        variable: {
+            kind: graphql_1.Kind.VARIABLE,
+            name: {
+                kind: graphql_1.Kind.NAME,
+                value: varName,
+            },
+        },
+        type: (0, astFromType_js_1.astFromType)(type),
+    };
+    if (value !== undefined) {
+        variableValues[varName] = value;
+        return;
+    }
+    // including the variable in the map with value of `undefined`
+    // will actually be translated by graphql-js into `null`
+    // see https://github.com/graphql/graphql-js/issues/2533
+    if (varName in variableValues) {
+        delete variableValues[varName];
+    }
+}
+exports.updateArgument = updateArgument;
+function createVariableNameGenerator(variableDefinitionMap) {
+    let varCounter = 0;
+    return (argName) => {
+        let varName;
+        do {
+            varName = `_v${(varCounter++).toString()}_${argName}`;
+        } while (varName in variableDefinitionMap);
+        return varName;
+    };
+}
+exports.createVariableNameGenerator = createVariableNameGenerator;

package/cjs/validate-documents.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createDefaultRules = exports.checkValidationErrors = exports.validateGraphQlDocuments = void 0;
+const graphql_1 = require("graphql");
+const AggregateError_js_1 = require("./AggregateError.js");
+async function validateGraphQlDocuments(schema, documentFiles, effectiveRules = createDefaultRules()) {
+    const allFragmentMap = new Map();
+    const documentFileObjectsToValidate = [];
+    for (const documentFile of documentFiles) {
+        if (documentFile.document) {
+            const definitionsToValidate = [];
+            for (const definitionNode of documentFile.document.definitions) {
+                if (definitionNode.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+                    allFragmentMap.set(definitionNode.name.value, definitionNode);
+                }
+                else {
+                    definitionsToValidate.push(definitionNode);
+                }
+            }
+            documentFileObjectsToValidate.push({
+                location: documentFile.location,
+                document: {
+                    kind: graphql_1.Kind.DOCUMENT,
+                    definitions: definitionsToValidate,
+                },
+            });
+        }
+    }
+    const allErrors = [];
+    const allFragmentsDocument = {
+        kind: graphql_1.Kind.DOCUMENT,
+        definitions: [...allFragmentMap.values()],
+    };
+    await Promise.all(documentFileObjectsToValidate.map(async (documentFile) => {
+        const documentToValidate = (0, graphql_1.concatAST)([allFragmentsDocument, documentFile.document]);
+        const errors = (0, graphql_1.validate)(schema, documentToValidate, effectiveRules);
+        if (errors.length > 0) {
+            allErrors.push({
+                filePath: documentFile.location,
+                errors,
+            });
+        }
+    }));
+    return allErrors;
+}
+exports.validateGraphQlDocuments = validateGraphQlDocuments;
+function checkValidationErrors(loadDocumentErrors) {
+    if (loadDocumentErrors.length > 0) {
+        const errors = [];
+        for (const loadDocumentError of loadDocumentErrors) {
+            for (const graphQLError of loadDocumentError.errors) {
+                const error = new Error();
+                error.name = 'GraphQLDocumentError';
+                error.message = `${error.name}: ${graphQLError.message}`;
+                error.stack = error.message;
+                if (graphQLError.locations) {
+                    for (const location of graphQLError.locations) {
+                        error.stack += `\n    at ${loadDocumentError.filePath}:${location.line}:${location.column}`;
+                    }
+                }
+                errors.push(error);
+            }
+        }
+        throw new AggregateError_js_1.AggregateError(errors, `GraphQL Document Validation failed with ${errors.length} errors;
+  ${errors.map((error, index) => `Error ${index}: ${error.stack}`).join('\n\n')}`);
+    }
+}
+exports.checkValidationErrors = checkValidationErrors;
+function createDefaultRules() {
+    let ignored = ['NoUnusedFragmentsRule', 'NoUnusedVariablesRule', 'KnownDirectivesRule'];
+    if (graphql_1.versionInfo.major < 15) {
+        ignored = ignored.map(rule => rule.replace(/Rule$/, ''));
+    }
+    return graphql_1.specifiedRules.filter((f) => !ignored.includes(f.name));
+}
+exports.createDefaultRules = createDefaultRules;

package/cjs/valueMatchesCriteria.js

@@ -0,0 +1,21 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.valueMatchesCriteria = void 0;
+function valueMatchesCriteria(value, criteria) {
+    if (value == null) {
+        return value === criteria;
+    }
+    else if (Array.isArray(value)) {
+        return Array.isArray(criteria) && value.every((val, index) => valueMatchesCriteria(val, criteria[index]));
+    }
+    else if (typeof value === 'object') {
+        return (typeof criteria === 'object' &&
+            criteria &&
+            Object.keys(criteria).every(propertyName => valueMatchesCriteria(value[propertyName], criteria[propertyName])));
+    }
+    else if (criteria instanceof RegExp) {
+        return criteria.test(value);
+    }
+    return value === criteria;
+}
+exports.valueMatchesCriteria = valueMatchesCriteria;