@graphql-mesh/runtime 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420181317-a95037648

package/esm/get-mesh.js

@@ -0,0 +1,273 @@
+import { getOperationAST, specifiedRules, validate, } from 'graphql';
+import { envelop, useEngine, useExtendContext } from '@envelop/core';
+import { OneOfInputObjectsRule, useExtendedValidation } from '@envelop/extended-validation';
+import { process } from '@graphql-mesh/cross-helpers';
+import { applySchemaTransforms, DefaultLogger, getHeadersObj, groupTransforms, parseWithCache, PubSub, } from '@graphql-mesh/utils';
+import { Subschema } from '@graphql-tools/delegate';
+import { AggregateError, getRootTypeMap, inspect, isAsyncIterable, mapAsyncIterator, memoize1, } from '@graphql-tools/utils';
+import { fetch as defaultFetchFn } from '@whatwg-node/fetch';
+import { MESH_CONTEXT_SYMBOL } from './constants.js';
+import { getInContextSDK } from './in-context-sdk.js';
+import { useSubschema } from './useSubschema.js';
+const memoizedGetEnvelopedFactory = memoize1(function getEnvelopedFactory(plugins) {
+    return envelop({
+        plugins,
+    });
+});
+const memoizedGetOperationType = memoize1((document) => {
+    const operationAST = getOperationAST(document, undefined);
+    if (!operationAST) {
+        throw new Error('Must provide document with a valid operation');
+    }
+    return operationAST.operation;
+});
+export function wrapFetchWithPlugins(plugins) {
+    return async function wrappedFetchFn(url, options, context, info) {
+        if (url != null && typeof url !== 'string') {
+            throw new TypeError(`First parameter(url) of 'fetch' must be a string, got ${inspect(url)}`);
+        }
+        if (options != null && typeof options !== 'object') {
+            throw new TypeError(`Second parameter(options) of 'fetch' must be an object, got ${inspect(options)}`);
+        }
+        if (context != null && typeof context !== 'object') {
+            throw new TypeError(`Third parameter(context) of 'fetch' must be an object, got ${inspect(context)}`);
+        }
+        if (info != null && typeof info !== 'object') {
+            throw new TypeError(`Fourth parameter(info) of 'fetch' must be an object, got ${inspect(info)}`);
+        }
+        let fetchFn;
+        const doneHooks = [];
+        for (const plugin of plugins) {
+            if ((plugin === null || plugin === void 0 ? void 0 : plugin.onFetch) != null) {
+                const doneHook = await plugin.onFetch({
+                    fetchFn,
+                    setFetchFn(newFetchFn) {
+                        fetchFn = newFetchFn;
+                    },
+                    url,
+                    options,
+                    context,
+                    info,
+                });
+                if (doneHook) {
+                    doneHooks.push(doneHook);
+                }
+            }
+        }
+        let response = await fetchFn(url, options, context, info);
+        for (const doneHook of doneHooks) {
+            await doneHook({
+                response,
+                setResponse(newResponse) {
+                    response = newResponse;
+                },
+            });
+        }
+        return response;
+    };
+}
+// Use in-context-sdk for tracing
+function createProxyingResolverFactory(apiName, rootTypeMap) {
+    return function createProxyingResolver({ operation }) {
+        const rootType = rootTypeMap.get(operation);
+        return function proxyingResolver(root, args, context, info) {
+            var _a, _b;
+            if (!((_b = (_a = context === null || context === void 0 ? void 0 : context[apiName]) === null || _a === void 0 ? void 0 : _a[rootType.name]) === null || _b === void 0 ? void 0 : _b[info.fieldName])) {
+                throw new Error(`${info.fieldName} couldn't find in ${rootType.name} of ${apiName} as a ${operation}`);
+            }
+            return context[apiName][rootType.name][info.fieldName]({ root, args, context, info });
+        };
+    };
+}
+export async function getMesh(options) {
+    const rawSources = [];
+    const { pubsub = new PubSub(), cache, logger = new DefaultLogger('🕸️  Mesh'), additionalEnvelopPlugins = [], sources, merger, additionalResolvers = [], additionalTypeDefs = [], transforms = [], fetchFn = defaultFetchFn, } = options;
+    const getMeshLogger = logger.child('GetMesh');
+    getMeshLogger.debug(`Getting subschemas from source handlers`);
+    let failed = false;
+    const initialPluginList = [
+        // TODO: Not a good practise to expect users to be a Yoga user
+        useExtendContext(({ request, req }) => {
+            // Maybe Node-like environment
+            if (req === null || req === void 0 ? void 0 : req.headers) {
+                return {
+                    headers: getHeadersObj(req.headers),
+                };
+            }
+            // Fetch environment
+            if (request === null || request === void 0 ? void 0 : request.headers) {
+                return {
+                    headers: getHeadersObj(request.headers),
+                };
+            }
+            return {};
+        }),
+        useExtendContext(() => ({
+            pubsub,
+            cache,
+            logger,
+            [MESH_CONTEXT_SYMBOL]: true,
+        })),
+        {
+            onFetch({ setFetchFn }) {
+                setFetchFn(fetchFn);
+            },
+        },
+        {
+            onParse({ setParseFn }) {
+                setParseFn(parseWithCache);
+            },
+        },
+        ...additionalEnvelopPlugins,
+    ];
+    const wrappedFetchFn = wrapFetchWithPlugins(initialPluginList);
+    await Promise.allSettled(sources.map(async (apiSource) => {
+        const apiName = apiSource.name;
+        const sourceLogger = logger.child(apiName);
+        sourceLogger.debug(`Generating the schema`);
+        try {
+            const source = await apiSource.handler.getMeshSource({
+                fetchFn: wrappedFetchFn,
+            });
+            sourceLogger.debug(`The schema has been generated successfully`);
+            let apiSchema = source.schema;
+            sourceLogger.debug(`Analyzing transforms`);
+            let transforms;
+            const { wrapTransforms, noWrapTransforms } = groupTransforms(apiSource.transforms);
+            if (!(wrapTransforms === null || wrapTransforms === void 0 ? void 0 : wrapTransforms.length) && (noWrapTransforms === null || noWrapTransforms === void 0 ? void 0 : noWrapTransforms.length)) {
+                sourceLogger.debug(`${noWrapTransforms.length} bare transforms found and applying`);
+                apiSchema = applySchemaTransforms(apiSchema, source, null, noWrapTransforms);
+            }
+            else {
+                transforms = apiSource.transforms;
+            }
+            const rootTypeMap = getRootTypeMap(apiSchema);
+            rawSources.push({
+                name: apiName,
+                schema: apiSchema,
+                executor: source.executor,
+                transforms,
+                contextVariables: source.contextVariables || {},
+                handler: apiSource.handler,
+                batch: 'batch' in source ? source.batch : true,
+                merge: source.merge,
+                createProxyingResolver: createProxyingResolverFactory(apiName, rootTypeMap),
+            });
+        }
+        catch (e) {
+            sourceLogger.error(`Failed to generate the schema`, e);
+            failed = true;
+        }
+    }));
+    if (failed) {
+        throw new Error(`Schemas couldn't be generated successfully. Check for the logs by running Mesh${process.env.DEBUG == null
+            ? ' with DEBUG=1 environmental variable to get more verbose output'
+            : ''}.`);
+    }
+    getMeshLogger.debug(`Schemas have been generated by the source handlers`);
+    getMeshLogger.debug(`Merging schemas using the defined merging strategy.`);
+    const unifiedSubschema = await merger.getUnifiedSchema({
+        rawSources,
+        typeDefs: additionalTypeDefs,
+        resolvers: additionalResolvers,
+    });
+    unifiedSubschema.transforms = unifiedSubschema.transforms || [];
+    for (const rootLevelTransform of transforms) {
+        if (rootLevelTransform.noWrap) {
+            if (rootLevelTransform.transformSchema) {
+                unifiedSubschema.schema = rootLevelTransform.transformSchema(unifiedSubschema.schema, unifiedSubschema);
+            }
+        }
+        else {
+            unifiedSubschema.transforms.push(rootLevelTransform);
+        }
+    }
+    let inContextSDK$;
+    const subschema = new Subschema(unifiedSubschema);
+    const plugins = [
+        useEngine({
+            validate,
+            specifiedRules,
+        }),
+        useSubschema(subschema),
+        useExtendContext(() => {
+            if (!inContextSDK$) {
+                const onDelegateHooks = [];
+                for (const plugin of initialPluginList) {
+                    if ((plugin === null || plugin === void 0 ? void 0 : plugin.onDelegate) != null) {
+                        onDelegateHooks.push(plugin.onDelegate);
+                    }
+                }
+                inContextSDK$ = getInContextSDK(subschema.transformedSchema, rawSources, logger, onDelegateHooks);
+            }
+            return inContextSDK$;
+        }),
+        useExtendedValidation({
+            rules: [OneOfInputObjectsRule],
+        }),
+        ...initialPluginList,
+    ];
+    const EMPTY_ROOT_VALUE = {};
+    const EMPTY_CONTEXT_VALUE = {};
+    const EMPTY_VARIABLES_VALUE = {};
+    function createExecutor(globalContext = EMPTY_CONTEXT_VALUE) {
+        const getEnveloped = memoizedGetEnvelopedFactory(plugins);
+        const { schema, parse, execute, subscribe, contextFactory } = getEnveloped(globalContext);
+        return async function meshExecutor(documentOrSDL, variableValues = EMPTY_VARIABLES_VALUE, contextValue = EMPTY_CONTEXT_VALUE, rootValue = EMPTY_ROOT_VALUE, operationName) {
+            const document = typeof documentOrSDL === 'string' ? parse(documentOrSDL) : documentOrSDL;
+            const executeFn = memoizedGetOperationType(document) === 'subscription' ? subscribe : execute;
+            return executeFn({
+                schema,
+                document,
+                contextValue: await contextFactory(contextValue),
+                rootValue,
+                variableValues: variableValues,
+                operationName,
+            });
+        };
+    }
+    function sdkRequesterFactory(globalContext) {
+        const executor = createExecutor(globalContext);
+        return async function sdkRequester(...args) {
+            const result = await executor(...args);
+            if (isAsyncIterable(result)) {
+                return mapAsyncIterator(result, extractDataOrThrowErrors);
+            }
+            return extractDataOrThrowErrors(result);
+        };
+    }
+    function meshDestroy() {
+        return pubsub.publish('destroy', undefined);
+    }
+    return {
+        get schema() {
+            return subschema.transformedSchema;
+        },
+        rawSources,
+        cache,
+        pubsub,
+        destroy: meshDestroy,
+        logger,
+        plugins,
+        get getEnveloped() {
+            return memoizedGetEnvelopedFactory(plugins);
+        },
+        createExecutor,
+        get execute() {
+            return createExecutor();
+        },
+        get subscribe() {
+            return createExecutor();
+        },
+        sdkRequesterFactory,
+    };
+}
+function extractDataOrThrowErrors(result) {
+    if (result.errors) {
+        if (result.errors.length === 1) {
+            throw result.errors[0];
+        }
+        throw new AggregateError(result.errors);
+    }
+    return result.data;
+}

package/esm/in-context-sdk.js

@@ -0,0 +1,234 @@
+import { getNamedType, isLeafType, Kind, } from 'graphql';
+import { parseWithCache } from '@graphql-mesh/utils';
+import { batchDelegateToSchema } from '@graphql-tools/batch-delegate';
+import { delegateToSchema, } from '@graphql-tools/delegate';
+import { isDocumentNode, memoize1 } from '@graphql-tools/utils';
+import { WrapQuery } from '@graphql-tools/wrap';
+import { MESH_API_CONTEXT_SYMBOL } from './constants.js';
+export async function getInContextSDK(unifiedSchema, rawSources, logger, onDelegateHooks) {
+    const inContextSDK = {};
+    const sourceMap = unifiedSchema.extensions.sourceMap;
+    for (const rawSource of rawSources) {
+        const rawSourceLogger = logger.child(`${rawSource.name}`);
+        const rawSourceContext = {
+            rawSource,
+            [MESH_API_CONTEXT_SYMBOL]: true,
+        };
+        // TODO: Somehow rawSource reference got lost in somewhere
+        let rawSourceSubSchemaConfig;
+        const stitchingInfo = unifiedSchema.extensions.stitchingInfo;
+        if (stitchingInfo) {
+            for (const [subschemaConfig, subschema] of stitchingInfo.subschemaMap) {
+                if (subschemaConfig.name === rawSource.name) {
+                    rawSourceSubSchemaConfig = subschema;
+                    break;
+                }
+            }
+        }
+        else {
+            rawSourceSubSchemaConfig = rawSource;
+        }
+        // If there is a single source, there is no unifiedSchema
+        const transformedSchema = sourceMap.get(rawSource);
+        const rootTypes = {
+            query: transformedSchema.getQueryType(),
+            mutation: transformedSchema.getMutationType(),
+            subscription: transformedSchema.getSubscriptionType(),
+        };
+        rawSourceLogger.debug(`Generating In Context SDK`);
+        for (const operationType in rootTypes) {
+            const rootType = rootTypes[operationType];
+            if (rootType) {
+                rawSourceContext[rootType.name] = {};
+                const rootTypeFieldMap = rootType.getFields();
+                for (const fieldName in rootTypeFieldMap) {
+                    const rootTypeField = rootTypeFieldMap[fieldName];
+                    const inContextSdkLogger = rawSourceLogger.child(`InContextSDK.${rootType.name}.${fieldName}`);
+                    const namedReturnType = getNamedType(rootTypeField.type);
+                    const shouldHaveSelectionSet = !isLeafType(namedReturnType);
+                    rawSourceContext[rootType.name][fieldName] = async ({ root, args, context, info = {
+                        fieldName,
+                        fieldNodes: [],
+                        returnType: namedReturnType,
+                        parentType: rootType,
+                        path: {
+                            typename: rootType.name,
+                            key: fieldName,
+                            prev: undefined,
+                        },
+                        schema: transformedSchema,
+                        fragments: {},
+                        rootValue: root,
+                        operation: {
+                            kind: Kind.OPERATION_DEFINITION,
+                            operation: operationType,
+                            selectionSet: {
+                                kind: Kind.SELECTION_SET,
+                                selections: [],
+                            },
+                        },
+                        variableValues: {},
+                    }, selectionSet, key, argsFromKeys, valuesFromResults, }) => {
+                        inContextSdkLogger.debug(`Called with`, {
+                            args,
+                            key,
+                        });
+                        const commonDelegateOptions = {
+                            schema: rawSourceSubSchemaConfig,
+                            rootValue: root,
+                            operation: operationType,
+                            fieldName,
+                            context,
+                            transformedSchema,
+                            info,
+                            transforms: [],
+                        };
+                        // If there isn't an extraction of a value
+                        if (typeof selectionSet !== 'function') {
+                            commonDelegateOptions.returnType = rootTypeField.type;
+                        }
+                        if (shouldHaveSelectionSet) {
+                            let selectionCount = 0;
+                            for (const fieldNode of info.fieldNodes) {
+                                if (fieldNode.selectionSet != null) {
+                                    selectionCount += fieldNode.selectionSet.selections.length;
+                                }
+                            }
+                            if (selectionCount === 0) {
+                                if (!selectionSet) {
+                                    throw new Error(`You have to provide 'selectionSet' for context.${rawSource.name}.${rootType.name}.${fieldName}`);
+                                }
+                                commonDelegateOptions.info = {
+                                    ...info,
+                                    fieldNodes: [
+                                        {
+                                            ...info.fieldNodes[0],
+                                            selectionSet: {
+                                                kind: Kind.SELECTION_SET,
+                                                selections: [
+                                                    {
+                                                        kind: Kind.FIELD,
+                                                        name: {
+                                                            kind: Kind.NAME,
+                                                            value: '__typename',
+                                                        },
+                                                    },
+                                                ],
+                                            },
+                                        },
+                                        ...info.fieldNodes.slice(1),
+                                    ],
+                                };
+                            }
+                        }
+                        if (key && argsFromKeys) {
+                            const batchDelegationOptions = {
+                                ...commonDelegateOptions,
+                                key,
+                                argsFromKeys,
+                                valuesFromResults,
+                            };
+                            if (selectionSet) {
+                                const selectionSetFactory = normalizeSelectionSetParamOrFactory(selectionSet);
+                                const path = [fieldName];
+                                const wrapQueryTransform = new WrapQuery(path, selectionSetFactory, identical);
+                                batchDelegationOptions.transforms = [wrapQueryTransform];
+                            }
+                            const onDelegateHookDones = [];
+                            for (const onDelegateHook of onDelegateHooks) {
+                                const onDelegateDone = await onDelegateHook({
+                                    ...batchDelegationOptions,
+                                    sourceName: rawSource.name,
+                                    typeName: rootType.name,
+                                    fieldName,
+                                });
+                                if (onDelegateDone) {
+                                    onDelegateHookDones.push(onDelegateDone);
+                                }
+                            }
+                            let result = await batchDelegateToSchema(batchDelegationOptions);
+                            for (const onDelegateHookDone of onDelegateHookDones) {
+                                await onDelegateHookDone({
+                                    result,
+                                    setResult(newResult) {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                        else {
+                            const regularDelegateOptions = {
+                                ...commonDelegateOptions,
+                                args,
+                            };
+                            if (selectionSet) {
+                                const selectionSetFactory = normalizeSelectionSetParamOrFactory(selectionSet);
+                                const path = [fieldName];
+                                const wrapQueryTransform = new WrapQuery(path, selectionSetFactory, valuesFromResults || identical);
+                                regularDelegateOptions.transforms = [wrapQueryTransform];
+                            }
+                            const onDelegateHookDones = [];
+                            for (const onDelegateHook of onDelegateHooks) {
+                                const onDelegateDone = await onDelegateHook({
+                                    ...regularDelegateOptions,
+                                    sourceName: rawSource.name,
+                                    typeName: rootType.name,
+                                    fieldName,
+                                });
+                                if (onDelegateDone) {
+                                    onDelegateHookDones.push(onDelegateDone);
+                                }
+                            }
+                            let result = await delegateToSchema(regularDelegateOptions);
+                            for (const onDelegateHookDone of onDelegateHookDones) {
+                                await onDelegateHookDone({
+                                    result,
+                                    setResult(newResult) {
+                                        result = newResult;
+                                    },
+                                });
+                            }
+                            return result;
+                        }
+                    };
+                }
+            }
+        }
+        inContextSDK[rawSource.name] = rawSourceContext;
+    }
+    return inContextSDK;
+}
+function getSelectionSetFromDocumentNode(documentNode) {
+    const operationDefinition = documentNode.definitions.find(definition => definition.kind === Kind.OPERATION_DEFINITION);
+    if (!operationDefinition) {
+        throw new Error('DocumentNode must contain an OperationDefinitionNode');
+    }
+    return operationDefinition.selectionSet;
+}
+function normalizeSelectionSetParam(selectionSetParam) {
+    if (typeof selectionSetParam === 'string') {
+        const documentNode = parseWithCache(selectionSetParam);
+        return getSelectionSetFromDocumentNode(documentNode);
+    }
+    if (isDocumentNode(selectionSetParam)) {
+        return getSelectionSetFromDocumentNode(selectionSetParam);
+    }
+    return selectionSetParam;
+}
+const normalizeSelectionSetParamFactory = memoize1(function normalizeSelectionSetParamFactory(selectionSetParamFactory) {
+    const memoizedSelectionSetFactory = memoize1(selectionSetParamFactory);
+    return function selectionSetFactory(subtree) {
+        const selectionSetParam = memoizedSelectionSetFactory(subtree);
+        return normalizeSelectionSetParam(selectionSetParam);
+    };
+});
+function normalizeSelectionSetParamOrFactory(selectionSetParamOrFactory) {
+    if (typeof selectionSetParamOrFactory === 'function') {
+        return normalizeSelectionSetParamFactory(selectionSetParamOrFactory);
+    }
+    return () => normalizeSelectionSetParam(selectionSetParamOrFactory);
+}
+function identical(val) {
+    return val;
+}

package/esm/index.js

@@ -0,0 +1,3 @@
+export * from './get-mesh.js';
+export * from './types.js';
+export * from './useSubschema.js';

package/esm/types.js

@@ -0,0 +1 @@
+import { MESH_CONTEXT_SYMBOL } from './constants.js';

package/esm/useSubschema.js

@@ -0,0 +1,106 @@
+import { BREAK, execute, visit } from 'graphql';
+import { mapAsyncIterator } from '@envelop/core';
+import { applyRequestTransforms, applyResultTransforms } from '@graphql-mesh/utils';
+import { createBatchingExecutor } from '@graphql-tools/batch-execute';
+import { applySchemaTransforms, createDefaultExecutor, } from '@graphql-tools/delegate';
+import { getDefinedRootType, getOperationASTFromRequest, isAsyncIterable, printSchemaWithDirectives, } from '@graphql-tools/utils';
+var IntrospectionQueryType;
+(function (IntrospectionQueryType) {
+    IntrospectionQueryType["FEDERATION"] = "FEDERATION";
+    IntrospectionQueryType["REGULAR"] = "REGULAR";
+})(IntrospectionQueryType || (IntrospectionQueryType = {}));
+function getIntrospectionOperationType(operationAST) {
+    let introspectionQueryType = null;
+    visit(operationAST, {
+        Field: node => {
+            if (node.name.value === '__schema' || node.name.value === '__type') {
+                introspectionQueryType = IntrospectionQueryType.REGULAR;
+                return BREAK;
+            }
+            if (node.name.value === '_service') {
+                introspectionQueryType = IntrospectionQueryType.FEDERATION;
+                return BREAK;
+            }
+        },
+    });
+    return introspectionQueryType;
+}
+function getExecuteFn(subschema) {
+    return async function subschemaExecute(args) {
+        var _a;
+        const originalRequest = {
+            document: args.document,
+            variables: args.variableValues,
+            operationName: (_a = args.operationName) !== null && _a !== void 0 ? _a : undefined,
+            rootValue: args.rootValue,
+            context: args.contextValue,
+        };
+        const operationAST = getOperationASTFromRequest(originalRequest);
+        // TODO: We need more elegant solution
+        const introspectionQueryType = getIntrospectionOperationType(operationAST);
+        if (introspectionQueryType === IntrospectionQueryType.FEDERATION) {
+            const executionResult = {
+                data: {
+                    _service: {
+                        sdl: printSchemaWithDirectives(args.schema),
+                    },
+                },
+            };
+            return executionResult;
+        }
+        else if (introspectionQueryType === IntrospectionQueryType.REGULAR) {
+            return execute(args);
+        }
+        const delegationContext = {
+            subschema,
+            subschemaConfig: subschema,
+            targetSchema: args.schema,
+            operation: operationAST.operation,
+            fieldName: '',
+            context: args.contextValue,
+            rootValue: args.rootValue,
+            transforms: subschema.transforms,
+            transformedSchema: subschema.transformedSchema,
+            skipTypeMerging: true,
+            returnType: getDefinedRootType(args.schema, operationAST.operation),
+        };
+        let executor = subschema.executor;
+        if (executor == null) {
+            executor = createDefaultExecutor(subschema.schema);
+        }
+        if (subschema.batch) {
+            executor = createBatchingExecutor(executor);
+        }
+        const transformationContext = {};
+        const transformedRequest = applyRequestTransforms(originalRequest, delegationContext, transformationContext, subschema.transforms);
+        const originalResult = await executor(transformedRequest);
+        if (isAsyncIterable(originalResult)) {
+            return mapAsyncIterator(originalResult, singleResult => applyResultTransforms(singleResult, delegationContext, transformationContext, subschema.transforms));
+        }
+        const transformedResult = applyResultTransforms(originalResult, delegationContext, transformationContext, subschema.transforms);
+        return transformedResult;
+    };
+}
+// Creates an envelop plugin to execute a subschema inside Envelop
+export function useSubschema(subschema) {
+    const executeFn = getExecuteFn(subschema);
+    const plugin = {
+        onPluginInit({ setSchema }) {
+            // To prevent unwanted warnings from stitching
+            if (!('_transformedSchema' in subschema)) {
+                subschema.transformedSchema = applySchemaTransforms(subschema.schema, subschema);
+            }
+            subschema.transformedSchema.extensions =
+                subschema.transformedSchema.extensions || subschema.schema.extensions || {};
+            Object.assign(subschema.transformedSchema.extensions, subschema.schema.extensions);
+            setSchema(subschema.transformedSchema);
+        },
+        onExecute({ setExecuteFn }) {
+            setExecuteFn(executeFn);
+        },
+        onSubscribe({ setSubscribeFn }) {
+            setSubscribeFn(executeFn);
+        },
+    };
+    return plugin;
+}