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

package/cjs/visitResult.js

@@ -0,0 +1,219 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.visitResult = exports.visitErrors = exports.visitData = void 0;
+const getOperationASTFromRequest_js_1 = require("./getOperationASTFromRequest.js");
+const graphql_1 = require("graphql");
+const collectFields_js_1 = require("./collectFields.js");
+function visitData(data, enter, leave) {
+    if (Array.isArray(data)) {
+        return data.map(value => visitData(value, enter, leave));
+    }
+    else if (typeof data === 'object') {
+        const newData = enter != null ? enter(data) : data;
+        if (newData != null) {
+            for (const key in newData) {
+                const value = newData[key];
+                Object.defineProperty(newData, key, {
+                    value: visitData(value, enter, leave),
+                });
+            }
+        }
+        return leave != null ? leave(newData) : newData;
+    }
+    return data;
+}
+exports.visitData = visitData;
+function visitErrors(errors, visitor) {
+    return errors.map(error => visitor(error));
+}
+exports.visitErrors = visitErrors;
+function visitResult(result, request, schema, resultVisitorMap, errorVisitorMap) {
+    const fragments = request.document.definitions.reduce((acc, def) => {
+        if (def.kind === graphql_1.Kind.FRAGMENT_DEFINITION) {
+            acc[def.name.value] = def;
+        }
+        return acc;
+    }, {});
+    const variableValues = request.variables || {};
+    const errorInfo = {
+        segmentInfoMap: new Map(),
+        unpathedErrors: new Set(),
+    };
+    const data = result.data;
+    const errors = result.errors;
+    const visitingErrors = errors != null && errorVisitorMap != null;
+    const operationDocumentNode = (0, getOperationASTFromRequest_js_1.getOperationASTFromRequest)(request);
+    if (data != null && operationDocumentNode != null) {
+        result.data = visitRoot(data, operationDocumentNode, schema, fragments, variableValues, resultVisitorMap, visitingErrors ? errors : undefined, errorInfo);
+    }
+    if (errors != null && errorVisitorMap) {
+        result.errors = visitErrorsByType(errors, errorVisitorMap, errorInfo);
+    }
+    return result;
+}
+exports.visitResult = visitResult;
+function visitErrorsByType(errors, errorVisitorMap, errorInfo) {
+    const segmentInfoMap = errorInfo.segmentInfoMap;
+    const unpathedErrors = errorInfo.unpathedErrors;
+    const unpathedErrorVisitor = errorVisitorMap['__unpathed'];
+    return errors.map(originalError => {
+        const pathSegmentsInfo = segmentInfoMap.get(originalError);
+        const newError = pathSegmentsInfo == null
+            ? originalError
+            : pathSegmentsInfo.reduceRight((acc, segmentInfo) => {
+                const typeName = segmentInfo.type.name;
+                const typeVisitorMap = errorVisitorMap[typeName];
+                if (typeVisitorMap == null) {
+                    return acc;
+                }
+                const errorVisitor = typeVisitorMap[segmentInfo.fieldName];
+                return errorVisitor == null ? acc : errorVisitor(acc, segmentInfo.pathIndex);
+            }, originalError);
+        if (unpathedErrorVisitor && unpathedErrors.has(originalError)) {
+            return unpathedErrorVisitor(newError);
+        }
+        return newError;
+    });
+}
+function getOperationRootType(schema, operationDef) {
+    switch (operationDef.operation) {
+        case 'query':
+            return schema.getQueryType();
+        case 'mutation':
+            return schema.getMutationType();
+        case 'subscription':
+            return schema.getSubscriptionType();
+    }
+}
+function visitRoot(root, operation, schema, fragments, variableValues, resultVisitorMap, errors, errorInfo) {
+    const operationRootType = getOperationRootType(schema, operation);
+    const collectedFields = (0, collectFields_js_1.collectFields)(schema, fragments, variableValues, operationRootType, operation.selectionSet, new Map(), new Set());
+    return visitObjectValue(root, operationRootType, collectedFields, schema, fragments, variableValues, resultVisitorMap, 0, errors, errorInfo);
+}
+function visitObjectValue(object, type, fieldNodeMap, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) {
+    var _a;
+    const fieldMap = type.getFields();
+    const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[type.name];
+    const enterObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__enter;
+    const newObject = enterObject != null ? enterObject(object) : object;
+    let sortedErrors;
+    let errorMap = null;
+    if (errors != null) {
+        sortedErrors = sortErrorsByPathSegment(errors, pathIndex);
+        errorMap = sortedErrors.errorMap;
+        for (const error of sortedErrors.unpathedErrors) {
+            errorInfo.unpathedErrors.add(error);
+        }
+    }
+    for (const [responseKey, subFieldNodes] of fieldNodeMap) {
+        const fieldName = subFieldNodes[0].name.value;
+        const fieldType = fieldName === '__typename' ? graphql_1.TypeNameMetaFieldDef.type : (_a = fieldMap[fieldName]) === null || _a === void 0 ? void 0 : _a.type;
+        const newPathIndex = pathIndex + 1;
+        let fieldErrors;
+        if (errorMap) {
+            fieldErrors = errorMap[responseKey];
+            if (fieldErrors != null) {
+                delete errorMap[responseKey];
+            }
+            addPathSegmentInfo(type, fieldName, newPathIndex, fieldErrors, errorInfo);
+        }
+        const newValue = visitFieldValue(object[responseKey], fieldType, subFieldNodes, schema, fragments, variableValues, resultVisitorMap, newPathIndex, fieldErrors, errorInfo);
+        updateObject(newObject, responseKey, newValue, typeVisitorMap, fieldName);
+    }
+    const oldTypename = newObject.__typename;
+    if (oldTypename != null) {
+        updateObject(newObject, '__typename', oldTypename, typeVisitorMap, '__typename');
+    }
+    if (errorMap) {
+        for (const errorsKey in errorMap) {
+            const errors = errorMap[errorsKey];
+            for (const error of errors) {
+                errorInfo.unpathedErrors.add(error);
+            }
+        }
+    }
+    const leaveObject = typeVisitorMap === null || typeVisitorMap === void 0 ? void 0 : typeVisitorMap.__leave;
+    return leaveObject != null ? leaveObject(newObject) : newObject;
+}
+function updateObject(object, responseKey, newValue, typeVisitorMap, fieldName) {
+    if (typeVisitorMap == null) {
+        object[responseKey] = newValue;
+        return;
+    }
+    const fieldVisitor = typeVisitorMap[fieldName];
+    if (fieldVisitor == null) {
+        object[responseKey] = newValue;
+        return;
+    }
+    const visitedValue = fieldVisitor(newValue);
+    if (visitedValue === undefined) {
+        delete object[responseKey];
+        return;
+    }
+    object[responseKey] = visitedValue;
+}
+function visitListValue(list, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo) {
+    return list.map(listMember => visitFieldValue(listMember, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex + 1, errors, errorInfo));
+}
+function visitFieldValue(value, returnType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors = [], errorInfo) {
+    if (value == null) {
+        return value;
+    }
+    const nullableType = (0, graphql_1.getNullableType)(returnType);
+    if ((0, graphql_1.isListType)(nullableType)) {
+        return visitListValue(value, nullableType.ofType, fieldNodes, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    else if ((0, graphql_1.isAbstractType)(nullableType)) {
+        const finalType = schema.getType(value.__typename);
+        const collectedFields = (0, collectFields_js_1.collectSubFields)(schema, fragments, variableValues, finalType, fieldNodes);
+        return visitObjectValue(value, finalType, collectedFields, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    else if ((0, graphql_1.isObjectType)(nullableType)) {
+        const collectedFields = (0, collectFields_js_1.collectSubFields)(schema, fragments, variableValues, nullableType, fieldNodes);
+        return visitObjectValue(value, nullableType, collectedFields, schema, fragments, variableValues, resultVisitorMap, pathIndex, errors, errorInfo);
+    }
+    const typeVisitorMap = resultVisitorMap === null || resultVisitorMap === void 0 ? void 0 : resultVisitorMap[nullableType.name];
+    if (typeVisitorMap == null) {
+        return value;
+    }
+    const visitedValue = typeVisitorMap(value);
+    return visitedValue === undefined ? value : visitedValue;
+}
+function sortErrorsByPathSegment(errors, pathIndex) {
+    var _a;
+    const errorMap = Object.create(null);
+    const unpathedErrors = new Set();
+    for (const error of errors) {
+        const pathSegment = (_a = error.path) === null || _a === void 0 ? void 0 : _a[pathIndex];
+        if (pathSegment == null) {
+            unpathedErrors.add(error);
+            continue;
+        }
+        if (pathSegment in errorMap) {
+            errorMap[pathSegment].push(error);
+        }
+        else {
+            errorMap[pathSegment] = [error];
+        }
+    }
+    return {
+        errorMap,
+        unpathedErrors,
+    };
+}
+function addPathSegmentInfo(type, fieldName, pathIndex, errors = [], errorInfo) {
+    for (const error of errors) {
+        const segmentInfo = {
+            type,
+            fieldName,
+            pathIndex,
+        };
+        const pathSegmentsInfo = errorInfo.segmentInfoMap.get(error);
+        if (pathSegmentsInfo == null) {
+            errorInfo.segmentInfoMap.set(error, [segmentInfo]);
+        }
+        else {
+            pathSegmentsInfo.push(segmentInfo);
+        }
+    }
+}

package/cjs/withCancel.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCancel = exports.getAsyncIterableWithCancel = exports.getAsyncIteratorWithCancel = void 0;
+const memoize_js_1 = require("./memoize.js");
+async function defaultAsyncIteratorReturn(value) {
+    return { value, done: true };
+}
+const proxyMethodFactory = (0, memoize_js_1.memoize2)(function proxyMethodFactory(target, targetMethod) {
+    return function proxyMethod(...args) {
+        return Reflect.apply(targetMethod, target, args);
+    };
+});
+function getAsyncIteratorWithCancel(asyncIterator, onCancel) {
+    return new Proxy(asyncIterator, {
+        has(asyncIterator, prop) {
+            if (prop === 'return') {
+                return true;
+            }
+            return Reflect.has(asyncIterator, prop);
+        },
+        get(asyncIterator, prop, receiver) {
+            const existingPropValue = Reflect.get(asyncIterator, prop, receiver);
+            if (prop === 'return') {
+                const existingReturn = existingPropValue || defaultAsyncIteratorReturn;
+                return async function returnWithCancel(value) {
+                    const returnValue = await onCancel(value);
+                    return Reflect.apply(existingReturn, asyncIterator, [returnValue]);
+                };
+            }
+            else if (typeof existingPropValue === 'function') {
+                return proxyMethodFactory(asyncIterator, existingPropValue);
+            }
+            return existingPropValue;
+        },
+    });
+}
+exports.getAsyncIteratorWithCancel = getAsyncIteratorWithCancel;
+function getAsyncIterableWithCancel(asyncIterable, onCancel) {
+    return new Proxy(asyncIterable, {
+        get(asyncIterable, prop, receiver) {
+            const existingPropValue = Reflect.get(asyncIterable, prop, receiver);
+            if (Symbol.asyncIterator === prop) {
+                return function asyncIteratorFactory() {
+                    const asyncIterator = Reflect.apply(existingPropValue, asyncIterable, []);
+                    return getAsyncIteratorWithCancel(asyncIterator, onCancel);
+                };
+            }
+            else if (typeof existingPropValue === 'function') {
+                return proxyMethodFactory(asyncIterable, existingPropValue);
+            }
+            return existingPropValue;
+        },
+    });
+}
+exports.getAsyncIterableWithCancel = getAsyncIterableWithCancel;
+exports.withCancel = getAsyncIterableWithCancel;

package/esm/AggregateError.js

@@ -0,0 +1,21 @@
+let AggregateErrorImpl;
+if (typeof AggregateError === 'undefined') {
+    class AggregateErrorClass extends Error {
+        constructor(errors, message = '') {
+            super(message);
+            this.errors = errors;
+            this.name = 'AggregateError';
+            Error.captureStackTrace(this, AggregateErrorClass);
+        }
+    }
+    AggregateErrorImpl = function (errors, message) {
+        return new AggregateErrorClass(errors, message);
+    };
+}
+else {
+    AggregateErrorImpl = AggregateError;
+}
+export { AggregateErrorImpl as AggregateError };
+export function isAggregateError(error) {
+    return 'errors' in error && Array.isArray(error['errors']);
+}

package/esm/Interfaces.js

@@ -0,0 +1,28 @@
+export var MapperKind;
+(function (MapperKind) {
+    MapperKind["TYPE"] = "MapperKind.TYPE";
+    MapperKind["SCALAR_TYPE"] = "MapperKind.SCALAR_TYPE";
+    MapperKind["ENUM_TYPE"] = "MapperKind.ENUM_TYPE";
+    MapperKind["COMPOSITE_TYPE"] = "MapperKind.COMPOSITE_TYPE";
+    MapperKind["OBJECT_TYPE"] = "MapperKind.OBJECT_TYPE";
+    MapperKind["INPUT_OBJECT_TYPE"] = "MapperKind.INPUT_OBJECT_TYPE";
+    MapperKind["ABSTRACT_TYPE"] = "MapperKind.ABSTRACT_TYPE";
+    MapperKind["UNION_TYPE"] = "MapperKind.UNION_TYPE";
+    MapperKind["INTERFACE_TYPE"] = "MapperKind.INTERFACE_TYPE";
+    MapperKind["ROOT_OBJECT"] = "MapperKind.ROOT_OBJECT";
+    MapperKind["QUERY"] = "MapperKind.QUERY";
+    MapperKind["MUTATION"] = "MapperKind.MUTATION";
+    MapperKind["SUBSCRIPTION"] = "MapperKind.SUBSCRIPTION";
+    MapperKind["DIRECTIVE"] = "MapperKind.DIRECTIVE";
+    MapperKind["FIELD"] = "MapperKind.FIELD";
+    MapperKind["COMPOSITE_FIELD"] = "MapperKind.COMPOSITE_FIELD";
+    MapperKind["OBJECT_FIELD"] = "MapperKind.OBJECT_FIELD";
+    MapperKind["ROOT_FIELD"] = "MapperKind.ROOT_FIELD";
+    MapperKind["QUERY_ROOT_FIELD"] = "MapperKind.QUERY_ROOT_FIELD";
+    MapperKind["MUTATION_ROOT_FIELD"] = "MapperKind.MUTATION_ROOT_FIELD";
+    MapperKind["SUBSCRIPTION_ROOT_FIELD"] = "MapperKind.SUBSCRIPTION_ROOT_FIELD";
+    MapperKind["INTERFACE_FIELD"] = "MapperKind.INTERFACE_FIELD";
+    MapperKind["INPUT_OBJECT_FIELD"] = "MapperKind.INPUT_OBJECT_FIELD";
+    MapperKind["ARGUMENT"] = "MapperKind.ARGUMENT";
+    MapperKind["ENUM_VALUE"] = "MapperKind.ENUM_VALUE";
+})(MapperKind || (MapperKind = {}));

package/esm/addTypes.js

@@ -0,0 +1,58 @@
+// addTypes uses toConfig to create a new schema with a new or replaced
+// type or directive. Rewiring is employed so that the replaced type can be
+// reconnected with the existing types.
+//
+// Rewiring is employed even for new types or directives as a convenience, so
+// that type references within the new type or directive do not have to be to
+// the identical objects within the original schema.
+//
+// In fact, the type references could even be stub types with entirely different
+// fields, as long as the type references share the same name as the desired
+// type within the original schema's type map.
+//
+// This makes it easy to perform simple schema operations (e.g. adding a new
+// type with a fiew fields removed from an existing type) that could normally be
+// performed by using toConfig directly, but is blocked if any intervening
+// more advanced schema operations have caused the types to be recreated via
+// rewiring.
+//
+// Type recreation happens, for example, with every use of mapSchema, as the
+// types are always rewired. If fields are selected and removed using
+// mapSchema, adding those fields to a new type can no longer be simply done
+// by toConfig, as the types are not the identical JavaScript objects, and
+// schema creation will fail with errors referencing multiple types with the
+// same names.
+//
+// enhanceSchema can fill this gap by adding an additional round of rewiring.
+//
+import { GraphQLSchema, isNamedType, isDirective } from 'graphql';
+import { getObjectTypeFromTypeMap } from './getObjectTypeFromTypeMap.js';
+import { rewireTypes } from './rewire.js';
+export function addTypes(schema, newTypesOrDirectives) {
+    const config = schema.toConfig();
+    const originalTypeMap = {};
+    for (const type of config.types) {
+        originalTypeMap[type.name] = type;
+    }
+    const originalDirectiveMap = {};
+    for (const directive of config.directives) {
+        originalDirectiveMap[directive.name] = directive;
+    }
+    for (const newTypeOrDirective of newTypesOrDirectives) {
+        if (isNamedType(newTypeOrDirective)) {
+            originalTypeMap[newTypeOrDirective.name] = newTypeOrDirective;
+        }
+        else if (isDirective(newTypeOrDirective)) {
+            originalDirectiveMap[newTypeOrDirective.name] = newTypeOrDirective;
+        }
+    }
+    const { typeMap, directives } = rewireTypes(originalTypeMap, Object.values(originalDirectiveMap));
+    return new GraphQLSchema({
+        ...config,
+        query: getObjectTypeFromTypeMap(typeMap, schema.getQueryType()),
+        mutation: getObjectTypeFromTypeMap(typeMap, schema.getMutationType()),
+        subscription: getObjectTypeFromTypeMap(typeMap, schema.getSubscriptionType()),
+        types: Object.values(typeMap),
+        directives,
+    });
+}

package/esm/astFromType.js

@@ -0,0 +1,27 @@
+import { isNonNullType, Kind, isListType } from 'graphql';
+import { inspect } from './inspect.js';
+export function astFromType(type) {
+    if (isNonNullType(type)) {
+        const innerType = astFromType(type.ofType);
+        if (innerType.kind === Kind.NON_NULL_TYPE) {
+            throw new Error(`Invalid type node ${inspect(type)}. Inner type of non-null type cannot be a non-null type.`);
+        }
+        return {
+            kind: Kind.NON_NULL_TYPE,
+            type: innerType,
+        };
+    }
+    else if (isListType(type)) {
+        return {
+            kind: Kind.LIST_TYPE,
+            type: astFromType(type.ofType),
+        };
+    }
+    return {
+        kind: Kind.NAMED_TYPE,
+        name: {
+            kind: Kind.NAME,
+            value: type.name,
+        },
+    };
+}

package/esm/astFromValueUntyped.js

@@ -0,0 +1,74 @@
+import { Kind } from 'graphql';
+/**
+ * Produces a GraphQL Value AST given a JavaScript object.
+ * Function will match JavaScript/JSON values to GraphQL AST schema format
+ * by using the following mapping.
+ *
+ * | JSON Value    | GraphQL Value        |
+ * | ------------- | -------------------- |
+ * | Object        | Input Object         |
+ * | Array         | List                 |
+ * | Boolean       | Boolean              |
+ * | String        | String               |
+ * | Number        | Int / Float          |
+ * | null          | NullValue            |
+ *
+ */
+export function astFromValueUntyped(value) {
+    // only explicit null, not undefined, NaN
+    if (value === null) {
+        return { kind: Kind.NULL };
+    }
+    // undefined
+    if (value === undefined) {
+        return null;
+    }
+    // Convert JavaScript array to GraphQL list. If the GraphQLType is a list, but
+    // the value is not an array, convert the value using the list's item type.
+    if (Array.isArray(value)) {
+        const valuesNodes = [];
+        for (const item of value) {
+            const itemNode = astFromValueUntyped(item);
+            if (itemNode != null) {
+                valuesNodes.push(itemNode);
+            }
+        }
+        return { kind: Kind.LIST, values: valuesNodes };
+    }
+    if (typeof value === 'object') {
+        const fieldNodes = [];
+        for (const fieldName in value) {
+            const fieldValue = value[fieldName];
+            const ast = astFromValueUntyped(fieldValue);
+            if (ast) {
+                fieldNodes.push({
+                    kind: Kind.OBJECT_FIELD,
+                    name: { kind: Kind.NAME, value: fieldName },
+                    value: ast,
+                });
+            }
+        }
+        return { kind: Kind.OBJECT, fields: fieldNodes };
+    }
+    // Others serialize based on their corresponding JavaScript scalar types.
+    if (typeof value === 'boolean') {
+        return { kind: Kind.BOOLEAN, value };
+    }
+    // JavaScript numbers can be Int or Float values.
+    if (typeof value === 'number' && isFinite(value)) {
+        const stringNum = String(value);
+        return integerStringRegExp.test(stringNum)
+            ? { kind: Kind.INT, value: stringNum }
+            : { kind: Kind.FLOAT, value: stringNum };
+    }
+    if (typeof value === 'string') {
+        return { kind: Kind.STRING, value };
+    }
+    throw new TypeError(`Cannot convert value to AST: ${value}.`);
+}
+/**
+ * IntValue:
+ *   - NegativeSign? 0
+ *   - NegativeSign? NonZeroDigit ( Digit+ )?
+ */
+const integerStringRegExp = /^-?(?:0|[1-9][0-9]*)$/;