@graphql-mesh/transport-rest 0.0.0

package/cjs/directives/dictionary.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDictionaryDirective = void 0;
+function processDictionaryDirective(fieldMap, field) {
+    field.resolve = function dictionaryDirectiveHandler(root) {
+        const result = [];
+        for (const key in root) {
+            if (key in fieldMap) {
+                continue;
+            }
+            result.push({
+                key,
+                value: root[key],
+            });
+        }
+        return result;
+    };
+}
+exports.processDictionaryDirective = processDictionaryDirective;

package/cjs/directives/discriminator.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDiscriminatorAnnotations = void 0;
+function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }) {
+    interfaceType.resolveType = function discriminatorDirectiveHandler(root) {
+        return root[discriminatorFieldName];
+    };
+}
+exports.processDiscriminatorAnnotations = processDiscriminatorAnnotations;

package/cjs/directives/flatten.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processFlattenAnnotations = void 0;
+function processFlattenAnnotations(field) {
+    if (!field.resolve || field.resolve.name === 'defaultFieldResolver') {
+        const fieldName = field.name;
+        field.resolve = function flattenDirectiveHandler(root) {
+            let result = root[fieldName];
+            if (!Array.isArray(root)) {
+                result = [result];
+            }
+            return result.flat(Infinity);
+        };
+    }
+}
+exports.processFlattenAnnotations = processFlattenAnnotations;

package/cjs/directives/getTypeResolverForAbstractType.js

@@ -0,0 +1,102 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getTypeResolverForAbstractType = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function getTypeResolverForAbstractType({ possibleTypes, discriminatorField, discriminatorMapping, statusCodeTypeNameMap, }) {
+    return function resolveType(data, _ctx, info) {
+        if (data.__typename) {
+            return data.__typename;
+        }
+        else if (discriminatorField != null && data[discriminatorField]) {
+            const discriminatorValue = data[discriminatorField];
+            return discriminatorMapping?.[discriminatorValue] || discriminatorValue;
+        }
+        if (data.$statusCode && statusCodeTypeNameMap) {
+            const typeName = statusCodeTypeNameMap[data.$statusCode.toString()] || statusCodeTypeNameMap.default;
+            if (typeName) {
+                return typeName;
+            }
+        }
+        const dataTypeOf = typeof data;
+        if (dataTypeOf !== 'object') {
+            for (const possibleType of possibleTypes) {
+                const fieldMap = possibleType.getFields();
+                const fields = Object.values(fieldMap);
+                if (fields.length === 1) {
+                    const field = fields[0];
+                    const directiveObjs = (0, utils_1.getDirective)(info.schema, field, 'resolveRoot');
+                    if (directiveObjs?.length) {
+                        const fieldType = field.type;
+                        if ('parseValue' in fieldType) {
+                            try {
+                                fieldType.parseValue(data);
+                                return possibleType.name;
+                            }
+                            catch (e) { }
+                        }
+                    }
+                }
+            }
+        }
+        // const validationErrors: Record<string, ErrorObject[]> = {};
+        const dataKeys = dataTypeOf
+            ? Object.keys(data)
+                // Remove metadata fields used to pass data
+                .filter(property => !property.toString().startsWith('$'))
+            : null;
+        const scoreTypeNameMap = new Map();
+        for (const possibleType of possibleTypes) {
+            const typeName = possibleType.name;
+            if (dataKeys != null) {
+                const typeFields = Object.keys(possibleType.getFields());
+                if (dataKeys.length <= typeFields.length &&
+                    dataKeys.every(property => typeFields.includes(property.toString()))) {
+                    return typeName;
+                }
+                else {
+                    const score = dataKeys.filter(property => typeFields.includes(property.toString())).length;
+                    if (score || typeFields.includes('additionalProperties')) {
+                        scoreTypeNameMap.set(score, typeName);
+                    }
+                }
+            } /* else {
+              const validateFn = possibleType.extensions.validateWithJSONSchema as ValidateFunction;
+              if (validateFn) {
+                const isValid = validateFn(data);
+                if (isValid) {
+                  return typeName;
+                }
+                validationErrors[typeName] = ajv.errors || validateFn.errors;
+              }
+            } */
+        }
+        const maxScore = Math.max(...scoreTypeNameMap.keys());
+        const typeName = scoreTypeNameMap.get(maxScore);
+        if (typeName) {
+            return typeName;
+        }
+        if (data.$response) {
+            const error = (0, utils_1.createGraphQLError)(`HTTP Error: ${data.$statusCode}`, {
+                extensions: {
+                    http: {
+                        status: data.$statusCode,
+                        headers: data.$response.header,
+                    },
+                    request: {
+                        url: data.$url,
+                        method: data.$method,
+                    },
+                    responseJson: data.$response,
+                },
+            });
+            return error;
+        }
+        /*
+        const error = new GraphQLError(`Received data doesn't met the union`, null, null, null, null, null, {
+          validationErrors,
+        });
+        return error;
+        */
+    };
+}
+exports.getTypeResolverForAbstractType = getTypeResolverForAbstractType;

package/cjs/directives/httpOperation.js

@@ -0,0 +1,404 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addHTTPRootFieldResolver = void 0;
+const tslib_1 = require("tslib");
+const dset_1 = require("dset");
+const graphql_1 = require("graphql");
+const qs_1 = require("qs");
+const url_join_1 = tslib_1.__importDefault(require("url-join"));
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
+const fetch_1 = require("@whatwg-node/fetch");
+const isFileUpload_js_1 = require("./isFileUpload.js");
+const jsonApiFields_js_1 = require("./jsonApiFields.js");
+const resolveDataByUnionInputType_js_1 = require("./resolveDataByUnionInputType.js");
+const isListTypeOrNonNullListType = (0, utils_2.memoize1)(function isListTypeOrNonNullListType(type) {
+    if ((0, graphql_1.isNonNullType)(type)) {
+        return (0, graphql_1.isListType)(type.ofType);
+    }
+    return (0, graphql_1.isListType)(type);
+});
+const defaultQsOptions = {
+    indices: false,
+};
+function addHTTPRootFieldResolver(schema, field, globalLogger = new utils_1.DefaultLogger('HTTP'), globalFetch, { path, operationSpecificHeaders, httpMethod, isBinary, requestBaseBody, queryParamArgMap, queryStringOptionsByParam, jsonApiFields, }, { sourceName, endpoint, timeout, operationHeaders: globalOperationHeaders, queryStringOptions: globalQueryStringOptions = {}, queryParams: globalQueryParams, }) {
+    globalQueryStringOptions = {
+        ...defaultQsOptions,
+        ...globalQueryStringOptions,
+    };
+    const returnNamedGraphQLType = (0, graphql_1.getNamedType)(field.type);
+    field.resolve = async (root, args, context, info) => {
+        if (jsonApiFields) {
+            args.fields = undefined;
+        }
+        const logger = context?.logger || globalLogger;
+        const operationLogger = logger.child(`${info.parentType.name}.${info.fieldName}`);
+        operationLogger.debug(`=> Resolving`);
+        const interpolationData = { root, args, context, env: cross_helpers_1.process.env };
+        const interpolatedBaseUrl = string_interpolation_1.stringInterpolator.parse(endpoint, interpolationData);
+        const interpolatedPath = string_interpolation_1.stringInterpolator.parse(path, interpolationData);
+        let fullPath = (0, url_join_1.default)(interpolatedBaseUrl, interpolatedPath);
+        const headers = {};
+        for (const headerName in globalOperationHeaders) {
+            const nonInterpolatedValue = globalOperationHeaders[headerName];
+            const interpolatedValue = string_interpolation_1.stringInterpolator.parse(nonInterpolatedValue, interpolationData);
+            if (interpolatedValue) {
+                headers[headerName.toLowerCase()] = interpolatedValue;
+            }
+        }
+        if (operationSpecificHeaders) {
+            for (const headerName in operationSpecificHeaders) {
+                const nonInterpolatedValue = operationSpecificHeaders[headerName];
+                const interpolatedValue = string_interpolation_1.stringInterpolator.parse(nonInterpolatedValue, interpolationData);
+                if (interpolatedValue) {
+                    headers[headerName.toLowerCase()] = interpolatedValue;
+                }
+            }
+        }
+        const requestInit = {
+            method: httpMethod,
+            headers,
+        };
+        if (timeout) {
+            requestInit.signal = AbortSignal.timeout(timeout);
+        }
+        // Handle binary data
+        if (isBinary) {
+            const binaryUpload = await args.input;
+            if ((0, isFileUpload_js_1.isFileUpload)(binaryUpload)) {
+                const readable = binaryUpload.createReadStream();
+                const chunks = [];
+                for await (const chunk of readable) {
+                    for (const byte of chunk) {
+                        chunks.push(byte);
+                    }
+                }
+                requestInit.body = new Uint8Array(chunks);
+                const [, contentType] = Object.entries(headers).find(([key]) => key.toLowerCase() === 'content-type') || [];
+                if (!contentType) {
+                    headers['content-type'] = binaryUpload.mimetype;
+                }
+            }
+            requestInit.body = binaryUpload;
+        }
+        else {
+            if (requestBaseBody != null) {
+                args.input = args.input || {};
+                for (const key in requestBaseBody) {
+                    const configValue = requestBaseBody[key];
+                    if (typeof configValue === 'string') {
+                        const value = string_interpolation_1.stringInterpolator.parse(configValue, interpolationData);
+                        (0, dset_1.dset)(args.input, key, value);
+                    }
+                    else {
+                        args.input[key] = configValue;
+                    }
+                }
+            }
+            // Resolve union input
+            const input = (args.input = (0, resolveDataByUnionInputType_js_1.resolveDataByUnionInputType)(args.input, field.args?.find(arg => arg.name === 'input')?.type, schema));
+            if (input != null) {
+                const [, contentType] = Object.entries(headers).find(([key]) => key.toLowerCase() === 'content-type') || [];
+                if (contentType?.startsWith('application/x-www-form-urlencoded')) {
+                    requestInit.body = (0, qs_1.stringify)(input, globalQueryStringOptions);
+                }
+                else if (contentType?.startsWith('multipart/form-data')) {
+                    delete headers['content-type'];
+                    delete headers['Content-Type'];
+                    const formData = new fetch_1.FormData();
+                    for (const key in input) {
+                        const inputValue = input[key];
+                        if (inputValue != null) {
+                            let formDataValue;
+                            if (typeof inputValue === 'object') {
+                                if (inputValue instanceof fetch_1.File) {
+                                    formDataValue = inputValue;
+                                }
+                                else if (inputValue.name && inputValue instanceof fetch_1.Blob) {
+                                    formDataValue = new fetch_1.File([inputValue], inputValue.name, {
+                                        type: inputValue.type,
+                                    });
+                                }
+                                else if (inputValue.arrayBuffer) {
+                                    const arrayBuffer = await inputValue.arrayBuffer();
+                                    if (inputValue.name) {
+                                        formDataValue = new fetch_1.File([arrayBuffer], inputValue.name, {
+                                            type: inputValue.type,
+                                        });
+                                    }
+                                    else {
+                                        formDataValue = new fetch_1.Blob([arrayBuffer], { type: inputValue.type });
+                                    }
+                                }
+                                else {
+                                    formDataValue = JSON.stringify(inputValue);
+                                }
+                            }
+                            else {
+                                formDataValue = inputValue.toString();
+                            }
+                            formData.append(key, formDataValue);
+                        }
+                    }
+                    requestInit.body = formData;
+                }
+                else if (contentType?.startsWith('text/plain')) {
+                    requestInit.body = input;
+                }
+                else {
+                    requestInit.body = JSON.stringify(input);
+                }
+            }
+        }
+        if (globalQueryParams) {
+            for (const queryParamName in globalQueryParams) {
+                if (queryParamArgMap != null &&
+                    queryParamName in queryParamArgMap &&
+                    queryParamArgMap[queryParamName] in args) {
+                    continue;
+                }
+                const interpolatedQueryParam = string_interpolation_1.stringInterpolator.parse(globalQueryParams[queryParamName].toString(), interpolationData);
+                const queryParamsString = (0, qs_1.stringify)({
+                    [queryParamName]: interpolatedQueryParam,
+                }, {
+                    ...globalQueryStringOptions,
+                    ...queryStringOptionsByParam?.[queryParamName],
+                });
+                fullPath += fullPath.includes('?') ? '&' : '?';
+                fullPath += queryParamsString;
+            }
+        }
+        if (queryParamArgMap) {
+            for (const queryParamName in queryParamArgMap) {
+                const argName = queryParamArgMap[queryParamName];
+                let argValue = args[argName];
+                if (argValue != null) {
+                    // Somehow it doesn't serialize URLs so we need to do it manually.
+                    if (argValue instanceof URL) {
+                        argValue = argValue.toString();
+                    }
+                    const opts = {
+                        ...globalQueryStringOptions,
+                        ...queryStringOptionsByParam?.[queryParamName],
+                    };
+                    let queryParamObj = argValue;
+                    if (Array.isArray(argValue) || !(typeof argValue === 'object' && opts.destructObject)) {
+                        queryParamObj = {
+                            [queryParamName]: argValue,
+                        };
+                    }
+                    else {
+                        queryParamObj = (0, resolveDataByUnionInputType_js_1.resolveDataByUnionInputType)(queryParamObj, field.args?.find(arg => arg.name === argName)?.type, schema);
+                    }
+                    const queryParamsString = (0, qs_1.stringify)(queryParamObj, opts);
+                    fullPath += fullPath.includes('?') ? '&' : '?';
+                    fullPath += queryParamsString;
+                }
+            }
+        }
+        if (jsonApiFields) {
+            fullPath += fullPath.includes('?') ? '&' : '?';
+            fullPath += `fields=${(0, jsonApiFields_js_1.getJsonApiFieldsQuery)(info)}`;
+        }
+        operationLogger.debug(`=> Fetching `, fullPath, `=>`, requestInit);
+        const fetch = context?.fetch || globalFetch;
+        if (!fetch) {
+            return (0, utils_2.createGraphQLError)(`You should have fetch defined in either the config or the context!`, {
+                extensions: {
+                    request: {
+                        url: fullPath,
+                        method: httpMethod,
+                    },
+                },
+            });
+        }
+        // Trick to pass `sourceName` to the `fetch` function for tracing
+        const response = await fetch(fullPath, requestInit, context, {
+            ...info,
+            sourceName,
+        });
+        // If return type is a file
+        if (returnNamedGraphQLType.name === 'File') {
+            return response.blob();
+        }
+        const responseText = await response.text();
+        operationLogger.debug(`=> Received`, {
+            headers: response.headers,
+            text: responseText,
+        });
+        let responseJson;
+        try {
+            responseJson = JSON.parse(responseText);
+        }
+        catch (error) {
+            // The result might be defined as scalar
+            if ((0, graphql_1.isScalarType)(returnNamedGraphQLType)) {
+                operationLogger.debug(` => Return type is not a JSON so returning ${responseText}`);
+                return responseText;
+            }
+            else if (response.status === 204 || (response.status === 200 && responseText === '')) {
+                responseJson = {};
+            }
+            else if (response.status.toString().startsWith('2')) {
+                logger.debug(`Unexpected response in ${field.name};\n\t${responseText}`);
+                return (0, utils_2.createGraphQLError)(`Unexpected response in ${field.name}`, {
+                    extensions: {
+                        http: {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: (0, utils_1.getHeadersObj)(response.headers),
+                        },
+                        request: {
+                            url: fullPath,
+                            method: httpMethod,
+                        },
+                        responseText,
+                        originalError: {
+                            message: error.message,
+                            stack: error.stack,
+                        },
+                    },
+                });
+            }
+            else {
+                return (0, utils_2.createGraphQLError)(`HTTP Error: ${response.status}, Could not invoke operation ${httpMethod} ${path}`, {
+                    extensions: {
+                        request: {
+                            url: fullPath,
+                            method: httpMethod,
+                        },
+                        responseText,
+                        responseStatus: response.status,
+                        responseStatusText: response.statusText,
+                        responseHeaders: (0, utils_1.getHeadersObj)(response.headers),
+                    },
+                });
+            }
+        }
+        if (!response.status.toString().startsWith('2')) {
+            if (!(0, graphql_1.isUnionType)(returnNamedGraphQLType)) {
+                return (0, utils_2.createGraphQLError)(`HTTP Error: ${response.status}, Could not invoke operation ${httpMethod} ${path}`, {
+                    extensions: {
+                        http: {
+                            status: response.status,
+                            statusText: response.statusText,
+                            headers: (0, utils_1.getHeadersObj)(response.headers),
+                        },
+                        request: {
+                            url: fullPath,
+                            method: httpMethod,
+                        },
+                        responseJson,
+                    },
+                });
+            }
+        }
+        operationLogger.debug(`Returning `, responseJson);
+        // Sometimes API returns an array but the return type is not an array
+        const isListReturnType = isListTypeOrNonNullListType(field.type);
+        const isArrayResponse = Array.isArray(responseJson);
+        if (isListReturnType && !isArrayResponse) {
+            operationLogger.debug(`Response is not array but return type is list. Normalizing the response`);
+            responseJson = [responseJson];
+        }
+        if (!isListReturnType && isArrayResponse) {
+            operationLogger.debug(`Response is array but return type is not list. Normalizing the response`);
+            responseJson = responseJson[0];
+        }
+        const addResponseMetadata = (obj) => {
+            if (typeof obj !== 'object') {
+                return obj;
+            }
+            Object.defineProperties(obj, {
+                $field: {
+                    get() {
+                        return field.name;
+                    },
+                },
+                $url: {
+                    get() {
+                        return fullPath.split('?')[0];
+                    },
+                },
+                $method: {
+                    get() {
+                        return httpMethod;
+                    },
+                },
+                $statusCode: {
+                    get() {
+                        return response.status;
+                    },
+                },
+                $statusText: {
+                    get() {
+                        return response.statusText;
+                    },
+                },
+                $headers: {
+                    get() {
+                        return requestInit.headers;
+                    },
+                },
+                $request: {
+                    get() {
+                        return new Proxy({}, {
+                            get(_, requestProp) {
+                                switch (requestProp) {
+                                    case 'query':
+                                        return (0, qs_1.parse)(fullPath.split('?')[1]);
+                                    case 'path':
+                                        return new Proxy(args, {
+                                            get(_, prop) {
+                                                return args[prop] || args.input?.[prop] || obj?.[prop];
+                                            },
+                                            has(_, prop) {
+                                                return prop in args || (args.input && prop in args.input) || obj?.[prop];
+                                            },
+                                        });
+                                    case 'header':
+                                        return requestInit.headers;
+                                    case 'body':
+                                        return requestInit.body;
+                                }
+                            },
+                        });
+                    },
+                },
+                $response: {
+                    get() {
+                        return new Proxy({}, {
+                            get(_, responseProp) {
+                                switch (responseProp) {
+                                    case 'header':
+                                        return (0, utils_1.getHeadersObj)(response.headers);
+                                    case 'body':
+                                        return obj;
+                                    case 'query':
+                                        return (0, qs_1.parse)(fullPath.split('?')[1]);
+                                    case 'path':
+                                        return new Proxy(args, {
+                                            get(_, prop) {
+                                                return args[prop] || args.input?.[prop] || obj?.[prop];
+                                            },
+                                            has(_, prop) {
+                                                return prop in args || (args.input && prop in args.input) || obj?.[prop];
+                                            },
+                                        });
+                                }
+                            },
+                        });
+                    },
+                },
+            });
+            return obj;
+        };
+        operationLogger.debug(`Adding response metadata to the response object`);
+        return Array.isArray(responseJson)
+            ? responseJson.map(obj => addResponseMetadata(obj))
+            : addResponseMetadata(responseJson);
+    };
+}
+exports.addHTTPRootFieldResolver = addHTTPRootFieldResolver;

package/cjs/directives/isFileUpload.js

@@ -0,0 +1,7 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isFileUpload = void 0;
+function isFileUpload(obj) {
+    return typeof obj.createReadStream === 'function';
+}
+exports.isFileUpload = isFileUpload;

package/cjs/directives/jsonApiFields.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getJsonApiFieldsQuery = void 0;
+const tslib_1 = require("tslib");
+const graphql_fields_1 = tslib_1.__importDefault(require("graphql-fields"));
+function handleFields(fields) {
+    const fieldsStrsArray = [];
+    for (const fieldName in fields) {
+        const subFields = fields[fieldName];
+        const subFieldsStr = handleFields(subFields);
+        let fieldStr = fieldName;
+        if (subFieldsStr) {
+            fieldStr += `(${subFieldsStr})`;
+        }
+        fieldsStrsArray.push(fieldStr);
+    }
+    return fieldsStrsArray.join(',');
+}
+function getJsonApiFieldsQuery(info) {
+    const fields = (0, graphql_fields_1.default)(info);
+    return handleFields(fields);
+}
+exports.getJsonApiFieldsQuery = getJsonApiFieldsQuery;

package/cjs/directives/length.js

@@ -0,0 +1,26 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLengthAnnotations = void 0;
+function processLengthAnnotations(scalar, { min: minLength, max: maxLength, }) {
+    function coerceString(value) {
+        if (value != null) {
+            const vStr = value.toString();
+            if (typeof minLength !== 'undefined' && vStr.length < minLength) {
+                throw new Error(`${scalar.name} cannot be less than ${minLength} but given ${vStr}`);
+            }
+            if (typeof maxLength !== 'undefined' && vStr.length > maxLength) {
+                throw new Error(`${scalar.name} cannot be more than ${maxLength} but given ${vStr}`);
+            }
+            return vStr;
+        }
+    }
+    scalar.serialize = coerceString;
+    scalar.parseValue = coerceString;
+    scalar.parseLiteral = ast => {
+        if ('value' in ast) {
+            return coerceString(ast.value);
+        }
+        return null;
+    };
+}
+exports.processLengthAnnotations = processLengthAnnotations;

package/cjs/directives/link.js

@@ -0,0 +1,67 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processLinkFieldAnnotations = void 0;
+const dset_1 = require("dset");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-tools/utils");
+function processLinkFieldAnnotations(field, defaultRootTypeName, defaultFieldName) {
+    field.resolve = function linkDirectiveHandler(root, args, context, info) {
+        const linkResolverMap = findLinkResolverMap({
+            schema: info.schema,
+            defaultRootTypeName,
+            defaultFieldName,
+            parentFieldName: root.$field,
+            operationType: info.operation.operation,
+        });
+        const linkResolverOpts = linkResolverMap[field.name];
+        return linkResolver(linkResolverOpts, { root, args, context, info, env: process.env });
+    };
+}
+exports.processLinkFieldAnnotations = processLinkFieldAnnotations;
+function findLinkResolverMap({ schema, operationType, defaultRootTypeName, defaultFieldName, }) {
+    const parentType = schema.getRootType(operationType);
+    const parentField = parentType.getFields()[operationType];
+    if (parentField) {
+        const linkResolverMap = getLinkResolverMap(schema, parentField);
+        if (linkResolverMap) {
+            return linkResolverMap;
+        }
+    }
+    const defaultRootType = schema.getType(defaultRootTypeName);
+    if (defaultRootType) {
+        const defaultField = defaultRootType.getFields()[defaultFieldName];
+        if (defaultField) {
+            const linkResolverMap = getLinkResolverMap(schema, defaultField);
+            if (linkResolverMap) {
+                return linkResolverMap;
+            }
+        }
+    }
+}
+function getLinkResolverMap(schema, field) {
+    const parentFieldLinkResolverDirectives = (0, utils_1.getDirective)(schema, field, 'linkResolver');
+    if (parentFieldLinkResolverDirectives?.length) {
+        const linkResolverMap = parentFieldLinkResolverDirectives[0].linkResolverMap;
+        if (linkResolverMap) {
+            return linkResolverMap;
+        }
+    }
+}
+function linkResolver({ linkObjArgs, targetTypeName, targetFieldName }, { root, args, context, info, env }) {
+    for (const argKey in linkObjArgs) {
+        const argInterpolation = linkObjArgs[argKey];
+        const actualValue = typeof argInterpolation === 'string'
+            ? string_interpolation_1.stringInterpolator.parse(argInterpolation, {
+                root,
+                args,
+                context,
+                info,
+                env,
+            })
+            : argInterpolation;
+        (0, dset_1.dset)(args, argKey, actualValue);
+    }
+    const type = info.schema.getType(targetTypeName);
+    const field = type.getFields()[targetFieldName];
+    return field.resolve(root, args, context, info);
+}