@graphql-mesh/transport-rest 0.0.0

package/cjs/directives/process.js

@@ -0,0 +1,181 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDirectives = void 0;
+const graphql_1 = require("graphql");
+const transport_common_1 = require("@graphql-mesh/transport-common");
+const utils_1 = require("@graphql-tools/utils");
+const dictionary_1 = require("./dictionary");
+const discriminator_1 = require("./discriminator");
+const flatten_1 = require("./flatten");
+const getTypeResolverForAbstractType_1 = require("./getTypeResolverForAbstractType");
+const httpOperation_1 = require("./httpOperation");
+const link_1 = require("./link");
+const pubsubOperation_1 = require("./pubsubOperation");
+const resolveRoot_1 = require("./resolveRoot");
+const resolveRootField_1 = require("./resolveRootField");
+const responseMetadata_1 = require("./responseMetadata");
+const scalars_1 = require("./scalars");
+const typescriptAnnotations_1 = require("./typescriptAnnotations");
+function processDirectives(schema, { globalFetch, logger, pubsub, ...extraGlobalOptions } = {}) {
+    const nonExecutableObjMapScalar = schema.getType('ObjMap');
+    if (nonExecutableObjMapScalar && (0, graphql_1.isScalarType)(nonExecutableObjMapScalar)) {
+        (0, scalars_1.addExecutionLogicToScalar)(nonExecutableObjMapScalar, transport_common_1.ObjMapScalar);
+    }
+    const transportDirectives = (0, utils_1.getDirective)(schema, schema, 'transport');
+    const currDirective = transportDirectives?.[0];
+    const globalOptions = {
+        endpoint: currDirective?.location,
+        operationHeaders: currDirective?.headers,
+        queryParams: currDirective?.queryParams,
+        queryStringOptions: currDirective?.queryStringOptions,
+        ...extraGlobalOptions,
+    };
+    if (typeof globalOptions.operationHeaders === 'string') {
+        globalOptions.operationHeaders = JSON.parse(globalOptions.operationHeaders);
+    }
+    if (typeof globalOptions.queryParams === 'string') {
+        globalOptions.queryParams = JSON.parse(globalOptions.queryParams);
+    }
+    const typeMap = schema.getTypeMap();
+    for (const typeName in typeMap) {
+        const type = typeMap[typeName];
+        const exampleAnnotations = (0, utils_1.getDirective)(schema, type, 'example');
+        if (exampleAnnotations?.length) {
+            const examples = [];
+            for (const exampleAnnotation of exampleAnnotations) {
+                if (exampleAnnotation?.value) {
+                    examples.push(exampleAnnotation.value);
+                }
+            }
+            type.extensions = type.extensions || {};
+            type.extensions.examples = examples;
+        }
+        if ((0, graphql_1.isScalarType)(type)) {
+            (0, scalars_1.processScalarType)(schema, type);
+        }
+        if ((0, graphql_1.isInterfaceType)(type)) {
+            const directiveAnnotations = (0, utils_1.getDirectives)(schema, type);
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'discriminator':
+                        (0, discriminator_1.processDiscriminatorAnnotations)({
+                            interfaceType: type,
+                            discriminatorFieldName: directiveAnnotation.args.field,
+                        });
+                        break;
+                }
+            }
+        }
+        if ((0, graphql_1.isUnionType)(type)) {
+            const directiveAnnotations = (0, utils_1.getDirectives)(schema, type);
+            let statusCodeTypeNameIndexMap;
+            let discriminatorField;
+            let discriminatorMapping;
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'statusCodeTypeName':
+                        statusCodeTypeNameIndexMap = statusCodeTypeNameIndexMap || {};
+                        statusCodeTypeNameIndexMap[directiveAnnotation.args.statusCode] =
+                            directiveAnnotation.args.typeName;
+                        break;
+                    case 'discriminator':
+                        discriminatorField = directiveAnnotation.args.field;
+                        discriminatorMapping = directiveAnnotation.args.mapping;
+                        break;
+                }
+            }
+            type.resolveType = (0, getTypeResolverForAbstractType_1.getTypeResolverForAbstractType)({
+                possibleTypes: type.getTypes(),
+                discriminatorField,
+                discriminatorMapping,
+                statusCodeTypeNameMap: statusCodeTypeNameIndexMap,
+            });
+        }
+        if ((0, graphql_1.isEnumType)(type)) {
+            const directiveAnnotations = (0, utils_1.getDirectives)(schema, type);
+            for (const directiveAnnotation of directiveAnnotations) {
+                switch (directiveAnnotation.name) {
+                    case 'typescript':
+                        (0, typescriptAnnotations_1.processTypeScriptAnnotations)(type, directiveAnnotation.args.type);
+                        break;
+                }
+            }
+            const enumValues = type.getValues();
+            for (const enumValue of enumValues) {
+                const directiveAnnotations = (0, utils_1.getDirectives)(schema, enumValue);
+                for (const directiveAnnotation of directiveAnnotations) {
+                    switch (directiveAnnotation.name) {
+                        case 'enum': {
+                            const realValue = JSON.parse(directiveAnnotation.args.value);
+                            enumValue.value = realValue;
+                            type._valueLookup.set(realValue, enumValue);
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        if ('getFields' in type) {
+            const fields = type.getFields();
+            for (const fieldName in fields) {
+                const field = fields[fieldName];
+                const directiveAnnotations = (0, utils_1.getDirectives)(schema, field);
+                for (const directiveAnnotation of directiveAnnotations) {
+                    switch (directiveAnnotation.name) {
+                        case 'resolveRoot':
+                            (0, resolveRoot_1.processResolveRootAnnotations)(field);
+                            break;
+                        case 'resolveRootField':
+                            (0, resolveRootField_1.processResolveRootFieldAnnotations)(field, directiveAnnotation.args.field);
+                            break;
+                        case 'flatten':
+                            (0, flatten_1.processFlattenAnnotations)(field);
+                            break;
+                        case 'pubsubOperation':
+                            (0, pubsubOperation_1.processPubSubOperationAnnotations)({
+                                field: field,
+                                pubsubTopic: directiveAnnotation.args.pubsubTopic,
+                                globalPubsub: pubsub,
+                                logger,
+                            });
+                            break;
+                        case 'httpOperation':
+                            (0, httpOperation_1.addHTTPRootFieldResolver)(schema, field, logger, globalFetch, 
+                            // TODO: Fix JSON parsing here for queryParams and headers
+                            {
+                                sourceName: directiveAnnotation.args.sourceName,
+                                endpoint: directiveAnnotation.args.endpoint,
+                                path: directiveAnnotation.args.path,
+                                httpMethod: directiveAnnotation.args.httpMethod,
+                                operationSpecificHeaders: typeof directiveAnnotation.args.operationSpecificHeaders === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.operationSpecificHeaders)
+                                    : directiveAnnotation.args.operationSpecificHeaders,
+                                isBinary: directiveAnnotation.args.isBinary,
+                                requestBaseBody: typeof directiveAnnotation.args.requestBaseBody === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.requestBaseBody)
+                                    : directiveAnnotation.args.requestBaseBody,
+                                queryParamArgMap: typeof directiveAnnotation.args.queryParamArgMap === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.queryParamArgMap)
+                                    : directiveAnnotation.args.queryParamArgMap,
+                                queryStringOptionsByParam: typeof directiveAnnotation.args.queryStringOptionsByParam === 'string'
+                                    ? JSON.parse(directiveAnnotation.args.queryStringOptionsByParam)
+                                    : directiveAnnotation.args.queryStringOptionsByParam,
+                                jsonApiFields: directiveAnnotation.args.jsonApiFields,
+                            }, globalOptions);
+                            break;
+                        case 'responseMetadata':
+                            (0, responseMetadata_1.processResponseMetadataAnnotations)(field);
+                            break;
+                        case 'link':
+                            (0, link_1.processLinkFieldAnnotations)(field, directiveAnnotation.args.defaultRootType, directiveAnnotation.args.defaultField);
+                            break;
+                        case 'dictionary':
+                            (0, dictionary_1.processDictionaryDirective)(fields, field);
+                    }
+                }
+            }
+        }
+    }
+    return schema;
+}
+exports.processDirectives = processDirectives;

package/cjs/directives/pubsubOperation.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processPubSubOperationAnnotations = void 0;
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-tools/utils");
+function processPubSubOperationAnnotations({ field, globalPubsub, pubsubTopic, logger: globalLogger, }) {
+    field.subscribe = function pubSubSubscribeFn(root, args, context, info) {
+        const logger = context?.logger || globalLogger;
+        const operationLogger = logger.child(`${info.parentType.name}.${field.name}`);
+        const pubsub = context?.pubsub || globalPubsub;
+        if (!pubsub) {
+            return (0, utils_1.createGraphQLError)(`You should have PubSub defined in either the config or the context!`);
+        }
+        const interpolationData = { root, args, context, info, env: process.env };
+        let interpolatedPubSubTopic = string_interpolation_1.stringInterpolator.parse(pubsubTopic, interpolationData);
+        if (interpolatedPubSubTopic.startsWith('webhook:')) {
+            const [, expectedMethod, expectedUrl] = interpolatedPubSubTopic.split(':');
+            const expectedPath = new URL(expectedUrl, 'http://localhost').pathname;
+            interpolatedPubSubTopic = `webhook:${expectedMethod}:${expectedPath}`;
+        }
+        operationLogger.debug(`${info.parentType.name}.${field.name} => Subscribing to pubSubTopic: ${interpolatedPubSubTopic}`);
+        return pubsub.asyncIterator(interpolatedPubSubTopic);
+    };
+    field.resolve = function pubSubResolver(root, args, context, info) {
+        const logger = context?.logger || globalLogger;
+        const operationLogger = logger.child(`${info.parentType.name}.${field.name}`);
+        operationLogger.debug('Received ', root, ' from ', pubsubTopic);
+        return root;
+    };
+}
+exports.processPubSubOperationAnnotations = processPubSubOperationAnnotations;

package/cjs/directives/regexp.js

@@ -0,0 +1,24 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processRegExpAnnotations = void 0;
+function processRegExpAnnotations(scalar, pattern) {
+    function coerceString(value) {
+        if (value != null) {
+            const vStr = value.toString();
+            const regexp = new RegExp(pattern);
+            if (!regexp.test(vStr)) {
+                throw new Error(`${scalar.name} must match ${pattern} 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.processRegExpAnnotations = processRegExpAnnotations;

package/cjs/directives/resolveDataByUnionInputType.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveDataByUnionInputType = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-mesh/utils");
+const utils_2 = require("@graphql-tools/utils");
+function resolveDataByUnionInputType(data, type, schema) {
+    if (data) {
+        if ((0, graphql_1.isListType)(type)) {
+            return (0, utils_2.asArray)(data).map(elem => resolveDataByUnionInputType(elem, type.ofType, schema));
+        }
+        if ((0, graphql_1.isNonNullType)(type)) {
+            return resolveDataByUnionInputType(data, type.ofType, schema);
+        }
+        if ((0, graphql_1.isInputObjectType)(type)) {
+            const typeOneOfDirectives = (0, utils_2.getDirective)(schema, type, 'oneOf');
+            const isOneOf = typeOneOfDirectives?.length;
+            const fieldMap = type.getFields();
+            data = (0, utils_2.asArray)(data)[0];
+            for (const propertyName in data) {
+                const fieldName = (0, utils_1.sanitizeNameForGraphQL)(propertyName);
+                const field = fieldMap[fieldName];
+                if (field) {
+                    if (isOneOf) {
+                        const resolvedData = resolveDataByUnionInputType(data[fieldName], field.type, schema);
+                        return resolvedData;
+                    }
+                    const fieldData = data[fieldName];
+                    data[fieldName] = undefined;
+                    const fieldResolveRootFieldDirectives = (0, utils_2.getDirective)(schema, field, 'resolveRootField');
+                    const realFieldName = fieldResolveRootFieldDirectives?.[0]?.field || fieldName;
+                    data[realFieldName] = resolveDataByUnionInputType(fieldData, field.type, schema);
+                }
+            }
+        }
+    }
+    return data;
+}
+exports.resolveDataByUnionInputType = resolveDataByUnionInputType;

package/cjs/directives/resolveRoot.js

@@ -0,0 +1,10 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResolveRootAnnotations = void 0;
+function rootResolver(root) {
+    return root;
+}
+function processResolveRootAnnotations(field) {
+    field.resolve = rootResolver;
+}
+exports.processResolveRootAnnotations = processResolveRootAnnotations;

package/cjs/directives/resolveRootField.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResolveRootFieldAnnotations = void 0;
+const graphql_1 = require("graphql");
+function isOriginallyListType(type) {
+    if ((0, graphql_1.isNonNullType)(type)) {
+        return isOriginallyListType(type.ofType);
+    }
+    return (0, graphql_1.isListType)(type);
+}
+function processResolveRootFieldAnnotations(field, propertyName) {
+    if (!field.resolve || field.resolve.name === 'defaultFieldResolver') {
+        field.resolve = (root, args, context, info) => {
+            const actualFieldObj = root[propertyName];
+            if (actualFieldObj != null) {
+                const isArray = Array.isArray(actualFieldObj);
+                const isListType = isOriginallyListType(info.returnType);
+                if (isListType && !isArray) {
+                    return [actualFieldObj];
+                }
+                else if (!isListType && isArray) {
+                    return actualFieldObj[0];
+                }
+            }
+            return actualFieldObj;
+        };
+    }
+}
+exports.processResolveRootFieldAnnotations = processResolveRootFieldAnnotations;

package/cjs/directives/responseMetadata.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processResponseMetadataAnnotations = void 0;
+function processResponseMetadataAnnotations(field) {
+    field.resolve = function responseMetadataResolver(root) {
+        return {
+            url: root.$url,
+            headers: root.$response.header,
+            method: root.$method,
+            status: root.$statusCode,
+            statusText: root.$statusText,
+            body: root.$response.body,
+        };
+    };
+}
+exports.processResponseMetadataAnnotations = processResponseMetadataAnnotations;

package/cjs/directives/scalars.js

@@ -0,0 +1,53 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addExecutionLogicToScalar = exports.processScalarType = void 0;
+const graphql_scalars_1 = require("graphql-scalars");
+const transport_common_1 = require("@graphql-mesh/transport-common");
+const utils_1 = require("@graphql-tools/utils");
+const length_js_1 = require("./length.js");
+const regexp_js_1 = require("./regexp.js");
+const typescriptAnnotations_js_1 = require("./typescriptAnnotations.js");
+function processScalarType(schema, type) {
+    if (type.name in graphql_scalars_1.resolvers) {
+        const actualScalar = graphql_scalars_1.resolvers[type.name];
+        addExecutionLogicToScalar(type, actualScalar);
+    }
+    if (type.name === 'ObjMap') {
+        addExecutionLogicToScalar(type, transport_common_1.ObjMapScalar);
+    }
+    const directiveAnnotations = (0, utils_1.getDirectives)(schema, type);
+    for (const directiveAnnotation of directiveAnnotations) {
+        switch (directiveAnnotation.name) {
+            case 'length':
+                (0, length_js_1.processLengthAnnotations)(type, directiveAnnotation.args);
+                break;
+            case 'regexp':
+                (0, regexp_js_1.processRegExpAnnotations)(type, directiveAnnotation.args.pattern);
+                break;
+            case 'typescript':
+                (0, typescriptAnnotations_js_1.processTypeScriptAnnotations)(type, directiveAnnotation.args.type);
+                break;
+        }
+    }
+}
+exports.processScalarType = processScalarType;
+function addExecutionLogicToScalar(nonExecutableScalar, actualScalar) {
+    Object.defineProperties(nonExecutableScalar, {
+        serialize: {
+            value: actualScalar.serialize,
+        },
+        parseValue: {
+            value: actualScalar.parseValue,
+        },
+        parseLiteral: {
+            value: actualScalar.parseLiteral,
+        },
+        extensions: {
+            value: {
+                ...actualScalar.extensions,
+                ...nonExecutableScalar.extensions,
+            },
+        },
+    });
+}
+exports.addExecutionLogicToScalar = addExecutionLogicToScalar;

package/cjs/directives/typescriptAnnotations.js

@@ -0,0 +1,8 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processTypeScriptAnnotations = void 0;
+function processTypeScriptAnnotations(type, typeDefinition) {
+    type.extensions = type.extensions || {};
+    type.extensions.codegenScalarType = typeDefinition;
+}
+exports.processTypeScriptAnnotations = processTypeScriptAnnotations;

package/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.processDirectives = exports.getSubgraphExecutor = void 0;
+const transport_common_1 = require("@graphql-mesh/transport-common");
+const process_1 = require("./directives/process");
+const getSubgraphExecutor = function getRESTSubgraphExecutor({ transportEntry, getSubgraph, fetch, pubsub, logger }) {
+    const preProcessedSchema = getSubgraph();
+    const processDirectiveOpts = {
+        globalFetch: fetch,
+        pubsub,
+        logger,
+        ...transportEntry.options,
+    };
+    const processedSchema = (0, process_1.processDirectives)(preProcessedSchema, processDirectiveOpts);
+    const executor = (0, transport_common_1.createDefaultExecutor)(processedSchema);
+    return executor;
+};
+exports.getSubgraphExecutor = getSubgraphExecutor;
+var process_2 = require("./directives/process");
+Object.defineProperty(exports, "processDirectives", { enumerable: true, get: function () { return process_2.processDirectives; } });

package/cjs/package.json

@@ -0,0 +1 @@
+{"type":"commonjs"}

package/esm/directives/dictionary.js

@@ -0,0 +1,15 @@
+export 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;
+    };
+}

package/esm/directives/discriminator.js

@@ -0,0 +1,5 @@
+export function processDiscriminatorAnnotations({ interfaceType, discriminatorFieldName, }) {
+    interfaceType.resolveType = function discriminatorDirectiveHandler(root) {
+        return root[discriminatorFieldName];
+    };
+}

package/esm/directives/flatten.js

@@ -0,0 +1,12 @@
+export 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);
+        };
+    }
+}

package/esm/directives/getTypeResolverForAbstractType.js

@@ -0,0 +1,98 @@
+import { createGraphQLError, getDirective } from '@graphql-tools/utils';
+export 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 = 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 = 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;
+        */
+    };
+}