@graphql-mesh/utils 1.0.0-alpha-3fc47d119.0 → 1.0.0-alpha-20230420181317-a95037648

package/esm/read-file-or-url.js

@@ -0,0 +1,124 @@
+import { DEFAULT_SCHEMA, load as loadYamlFromJsYaml, Type } from 'js-yaml';
+import { fs, path as pathModule } from '@graphql-mesh/cross-helpers';
+import { loadFromModuleExportExpression } from './load-from-module-export-expression.js';
+export function isUrl(str) {
+    return /^https?:\/\//.test(str);
+}
+export async function readFileOrUrl(filePathOrUrl, config) {
+    if (isUrl(filePathOrUrl)) {
+        config.logger.debug(`Fetching ${filePathOrUrl} via HTTP`);
+        return readUrl(filePathOrUrl, config);
+    }
+    else if (filePathOrUrl.startsWith('{') || filePathOrUrl.startsWith('[')) {
+        return JSON.parse(filePathOrUrl);
+    }
+    else {
+        config.logger.debug(`Reading ${filePathOrUrl} from the file system`);
+        return readFile(filePathOrUrl, config);
+    }
+}
+function getSchema(filepath, logger) {
+    return DEFAULT_SCHEMA.extend([
+        new Type('!include', {
+            kind: 'scalar',
+            resolve(path) {
+                return typeof path === 'string';
+            },
+            construct(path) {
+                const newCwd = pathModule.dirname(filepath);
+                const absoluteFilePath = pathModule.isAbsolute(path)
+                    ? path
+                    : pathModule.resolve(newCwd, path);
+                const content = fs.readFileSync(absoluteFilePath, 'utf8');
+                return loadYaml(absoluteFilePath, content, logger);
+            },
+        }),
+        new Type('!includes', {
+            kind: 'scalar',
+            resolve(path) {
+                return typeof path === 'string';
+            },
+            construct(path) {
+                const newCwd = pathModule.dirname(filepath);
+                const absoluteDirPath = pathModule.isAbsolute(path)
+                    ? path
+                    : pathModule.resolve(newCwd, path);
+                const files = fs.readdirSync(absoluteDirPath);
+                return files.map(filePath => {
+                    const absoluteFilePath = pathModule.resolve(absoluteDirPath, filePath);
+                    const fileContent = fs.readFileSync(absoluteFilePath, 'utf8');
+                    return loadYaml(absoluteFilePath, fileContent, logger);
+                });
+            },
+        }),
+    ]);
+}
+export function loadYaml(filepath, content, logger) {
+    return loadYamlFromJsYaml(content, {
+        filename: filepath,
+        schema: getSchema(filepath, logger),
+        onWarning(warning) {
+            logger.warn(`${filepath}: ${warning.message}\n${warning.stack}`);
+        },
+    });
+}
+export async function readFile(fileExpression, { allowUnknownExtensions, cwd, fallbackFormat, importFn, logger }) {
+    const [filePath] = fileExpression.split('#');
+    if (/js$/.test(filePath) || /ts$/.test(filePath)) {
+        return loadFromModuleExportExpression(fileExpression, {
+            cwd,
+            importFn,
+            defaultExportName: 'default',
+        });
+    }
+    const actualPath = pathModule.isAbsolute(filePath) ? filePath : pathModule.join(cwd, filePath);
+    const rawResult = await fs.promises.readFile(actualPath, 'utf-8');
+    if (/json$/.test(actualPath)) {
+        return JSON.parse(rawResult);
+    }
+    if (/yaml$/.test(actualPath) || /yml$/.test(actualPath)) {
+        return loadYaml(actualPath, rawResult, logger);
+    }
+    else if (fallbackFormat) {
+        switch (fallbackFormat) {
+            case 'json':
+                return JSON.parse(rawResult);
+            case 'yaml':
+                return loadYaml(actualPath, rawResult, logger);
+            case 'ts':
+            case 'js':
+                return importFn(actualPath);
+        }
+    }
+    else if (!allowUnknownExtensions) {
+        throw new Error(`Failed to parse JSON/YAML. Ensure file '${filePath}' has ` +
+            `the correct extension (i.e. '.json', '.yaml', or '.yml).`);
+    }
+    return rawResult;
+}
+export async function readUrl(path, config) {
+    var _a, _b;
+    const { allowUnknownExtensions, fallbackFormat } = config || {};
+    config.headers = config.headers || {};
+    const response = await config.fetch(path, config);
+    const contentType = ((_a = response.headers) === null || _a === void 0 ? void 0 : _a.get('content-type')) || '';
+    const responseText = await response.text();
+    (_b = config === null || config === void 0 ? void 0 : config.logger) === null || _b === void 0 ? void 0 : _b.debug(`${path} returned `, responseText);
+    if (/json$/.test(path) ||
+        contentType.startsWith('application/json') ||
+        fallbackFormat === 'json') {
+        return JSON.parse(responseText);
+    }
+    else if (/yaml$/.test(path) ||
+        /yml$/.test(path) ||
+        contentType.includes('yaml') ||
+        contentType.includes('yml') ||
+        fallbackFormat === 'yaml') {
+        return loadYaml(path, responseText, config === null || config === void 0 ? void 0 : config.logger);
+    }
+    else if (!allowUnknownExtensions) {
+        throw new Error(`Failed to parse JSON/YAML. Ensure URL '${path}' has ` +
+            `the correct extension (i.e. '.json', '.yaml', or '.yml) or mime type in the response headers.`);
+    }
+    return responseText;
+}

package/esm/resolve-additional-resolvers.js

@@ -0,0 +1,344 @@
+import { dset } from 'dset';
+import { getNamedType, isAbstractType, isInterfaceType, isObjectType, Kind, } from 'graphql';
+import lodashGet from 'lodash.get';
+import toPath from 'lodash.topath';
+import { process } from '@graphql-mesh/cross-helpers';
+import { stringInterpolator } from '@graphql-mesh/string-interpolation';
+import { parseSelectionSet } from '@graphql-tools/utils';
+import { loadFromModuleExportExpression } from './load-from-module-export-expression.js';
+import { withFilter } from './with-filter.js';
+function getTypeByPath(type, path) {
+    if ('ofType' in type) {
+        return getTypeByPath(getNamedType(type), path);
+    }
+    if (path.length === 0) {
+        return getNamedType(type);
+    }
+    if (!('getFields' in type)) {
+        throw new Error(`${type} cannot have a path ${path.join('.')}`);
+    }
+    const fieldMap = type.getFields();
+    const currentFieldName = path[0];
+    // Might be an index of an array
+    if (!Number.isNaN(parseInt(currentFieldName))) {
+        return getTypeByPath(type, path.slice(1));
+    }
+    const field = fieldMap[currentFieldName];
+    if (!(field === null || field === void 0 ? void 0 : field.type)) {
+        throw new Error(`${type}.${currentFieldName} is not a valid field.`);
+    }
+    return getTypeByPath(field.type, path.slice(1));
+}
+function generateSelectionSetFactory(schema, additionalResolver) {
+    if (additionalResolver.sourceSelectionSet) {
+        return () => parseSelectionSet(additionalResolver.sourceSelectionSet);
+        // If result path provided without a selectionSet
+    }
+    else if (additionalResolver.result) {
+        const resultPath = toPath(additionalResolver.result);
+        let abstractResultTypeName;
+        const sourceType = schema.getType(additionalResolver.sourceTypeName);
+        const sourceTypeFields = sourceType.getFields();
+        const sourceField = sourceTypeFields[additionalResolver.sourceFieldName];
+        const resultFieldType = getTypeByPath(sourceField.type, resultPath);
+        if (isAbstractType(resultFieldType)) {
+            if (additionalResolver.resultType) {
+                abstractResultTypeName = additionalResolver.resultType;
+            }
+            else {
+                const targetType = schema.getType(additionalResolver.targetTypeName);
+                const targetTypeFields = targetType.getFields();
+                const targetField = targetTypeFields[additionalResolver.targetFieldName];
+                const targetFieldType = getNamedType(targetField.type);
+                abstractResultTypeName = targetFieldType === null || targetFieldType === void 0 ? void 0 : targetFieldType.name;
+            }
+            if (abstractResultTypeName !== resultFieldType.name) {
+                const abstractResultType = schema.getType(abstractResultTypeName);
+                if ((isInterfaceType(abstractResultType) || isObjectType(abstractResultType)) &&
+                    !schema.isSubType(resultFieldType, abstractResultType)) {
+                    throw new Error(`${additionalResolver.sourceTypeName}.${additionalResolver.sourceFieldName}.${resultPath.join('.')} doesn't implement ${abstractResultTypeName}.}`);
+                }
+            }
+        }
+        return (subtree) => {
+            let finalSelectionSet = subtree;
+            let isLastResult = true;
+            const resultPathReversed = [...resultPath].reverse();
+            for (const pathElem of resultPathReversed) {
+                // Ensure the path elem is not array index
+                if (Number.isNaN(parseInt(pathElem))) {
+                    if (isLastResult &&
+                        abstractResultTypeName &&
+                        abstractResultTypeName !== resultFieldType.name) {
+                        finalSelectionSet = {
+                            kind: Kind.SELECTION_SET,
+                            selections: [
+                                {
+                                    kind: Kind.INLINE_FRAGMENT,
+                                    typeCondition: {
+                                        kind: Kind.NAMED_TYPE,
+                                        name: {
+                                            kind: Kind.NAME,
+                                            value: abstractResultTypeName,
+                                        },
+                                    },
+                                    selectionSet: finalSelectionSet,
+                                },
+                            ],
+                        };
+                    }
+                    finalSelectionSet = {
+                        kind: Kind.SELECTION_SET,
+                        selections: [
+                            {
+                                // we create a wrapping AST Field
+                                kind: Kind.FIELD,
+                                name: {
+                                    kind: Kind.NAME,
+                                    value: pathElem,
+                                },
+                                // Inside the field selection
+                                selectionSet: finalSelectionSet,
+                            },
+                        ],
+                    };
+                    isLastResult = false;
+                }
+            }
+            return finalSelectionSet;
+        };
+    }
+    return undefined;
+}
+function generateValuesFromResults(resultExpression) {
+    return function valuesFromResults(result) {
+        if (Array.isArray(result)) {
+            return result.map(valuesFromResults);
+        }
+        return lodashGet(result, resultExpression);
+    };
+}
+export function resolveAdditionalResolversWithoutImport(additionalResolver, pubsub) {
+    const baseOptions = {};
+    if (additionalResolver.result) {
+        baseOptions.valuesFromResults = generateValuesFromResults(additionalResolver.result);
+    }
+    if ('pubsubTopic' in additionalResolver) {
+        return {
+            [additionalResolver.targetTypeName]: {
+                [additionalResolver.targetFieldName]: {
+                    subscribe: withFilter((root, args, context, info) => {
+                        const resolverData = { root, args, context, info, env: process.env };
+                        const topic = stringInterpolator.parse(additionalResolver.pubsubTopic, resolverData);
+                        return pubsub.asyncIterator(topic);
+                    }, (root, args, context, info) => {
+                        return additionalResolver.filterBy
+                            ? // eslint-disable-next-line no-new-func
+                                new Function(`return ${additionalResolver.filterBy}`)()
+                            : true;
+                    }),
+                    resolve: (payload) => {
+                        if (baseOptions.valuesFromResults) {
+                            return baseOptions.valuesFromResults(payload);
+                        }
+                        return payload;
+                    },
+                },
+            },
+        };
+    }
+    else if ('keysArg' in additionalResolver) {
+        return {
+            [additionalResolver.targetTypeName]: {
+                [additionalResolver.targetFieldName]: {
+                    selectionSet: additionalResolver.requiredSelectionSet || `{ ${additionalResolver.keyField} }`,
+                    resolve: async (root, args, context, info) => {
+                        if (!baseOptions.selectionSet) {
+                            baseOptions.selectionSet = generateSelectionSetFactory(info.schema, additionalResolver);
+                        }
+                        const resolverData = { root, args, context, info, env: process.env };
+                        const targetArgs = {};
+                        for (const argPath in additionalResolver.additionalArgs || {}) {
+                            dset(targetArgs, argPath, stringInterpolator.parse(additionalResolver.additionalArgs[argPath], resolverData));
+                        }
+                        const options = {
+                            ...baseOptions,
+                            root,
+                            context,
+                            info,
+                            argsFromKeys: (keys) => {
+                                const args = {};
+                                dset(args, additionalResolver.keysArg, keys);
+                                Object.assign(args, targetArgs);
+                                return args;
+                            },
+                            key: lodashGet(root, additionalResolver.keyField),
+                        };
+                        return context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName](options);
+                    },
+                },
+            },
+        };
+    }
+    else if ('targetTypeName' in additionalResolver) {
+        return {
+            [additionalResolver.targetTypeName]: {
+                [additionalResolver.targetFieldName]: {
+                    selectionSet: additionalResolver.requiredSelectionSet,
+                    resolve: (root, args, context, info) => {
+                        // Assert source exists
+                        if (!context[additionalResolver.sourceName]) {
+                            throw new Error(`No source found named "${additionalResolver.sourceName}"`);
+                        }
+                        if (!context[additionalResolver.sourceName][additionalResolver.sourceTypeName]) {
+                            throw new Error(`No root type found named "${additionalResolver.sourceTypeName}" exists in the source ${additionalResolver.sourceName}\n` +
+                                `It should be one of the following; ${Object.keys(context[additionalResolver.sourceName]).join(',')})}}`);
+                        }
+                        if (!context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName]) {
+                            throw new Error(`No field named "${additionalResolver.sourceFieldName}" exists in the type ${additionalResolver.sourceTypeName} from the source ${additionalResolver.sourceName}`);
+                        }
+                        if (!baseOptions.selectionSet) {
+                            baseOptions.selectionSet = generateSelectionSetFactory(info.schema, additionalResolver);
+                        }
+                        const resolverData = { root, args, context, info, env: process.env };
+                        const targetArgs = {};
+                        for (const argPath in additionalResolver.sourceArgs) {
+                            dset(targetArgs, argPath, stringInterpolator.parse(additionalResolver.sourceArgs[argPath].toString(), resolverData));
+                        }
+                        const options = {
+                            ...baseOptions,
+                            root,
+                            args: targetArgs,
+                            context,
+                            info,
+                        };
+                        return context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName](options);
+                    },
+                },
+            },
+        };
+    }
+    else {
+        return additionalResolver;
+    }
+}
+export function resolveAdditionalResolvers(baseDir, additionalResolvers, importFn, pubsub) {
+    return Promise.all((additionalResolvers || []).map(async (additionalResolver) => {
+        if (typeof additionalResolver === 'string') {
+            const resolvers = await loadFromModuleExportExpression(additionalResolver, {
+                cwd: baseDir,
+                defaultExportName: 'resolvers',
+                importFn,
+            });
+            if (!resolvers) {
+                console.warn(`Unable to load resolvers from file: ${additionalResolver}`);
+                return {};
+            }
+            return resolvers;
+        }
+        else {
+            const baseOptions = {};
+            if (additionalResolver.result) {
+                baseOptions.valuesFromResults = generateValuesFromResults(additionalResolver.result);
+            }
+            if ('pubsubTopic' in additionalResolver) {
+                return {
+                    [additionalResolver.targetTypeName]: {
+                        [additionalResolver.targetFieldName]: {
+                            subscribe: withFilter((root, args, context, info) => {
+                                const resolverData = { root, args, context, info, env: process.env };
+                                const topic = stringInterpolator.parse(additionalResolver.pubsubTopic, resolverData);
+                                return pubsub.asyncIterator(topic);
+                            }, (root, args, context, info) => {
+                                return additionalResolver.filterBy
+                                    ? // eslint-disable-next-line no-new-func
+                                        new Function(`return ${additionalResolver.filterBy}`)()
+                                    : true;
+                            }),
+                            resolve: (payload) => {
+                                if (baseOptions.valuesFromResults) {
+                                    return baseOptions.valuesFromResults(payload);
+                                }
+                                return payload;
+                            },
+                        },
+                    },
+                };
+            }
+            else if ('keysArg' in additionalResolver) {
+                return {
+                    [additionalResolver.targetTypeName]: {
+                        [additionalResolver.targetFieldName]: {
+                            selectionSet: additionalResolver.requiredSelectionSet || `{ ${additionalResolver.keyField} }`,
+                            resolve: async (root, args, context, info) => {
+                                if (!baseOptions.selectionSet) {
+                                    baseOptions.selectionSet = generateSelectionSetFactory(info.schema, additionalResolver);
+                                }
+                                const resolverData = { root, args, context, info, env: process.env };
+                                const targetArgs = {};
+                                for (const argPath in additionalResolver.additionalArgs || {}) {
+                                    dset(targetArgs, argPath, stringInterpolator.parse(additionalResolver.additionalArgs[argPath], resolverData));
+                                }
+                                const options = {
+                                    ...baseOptions,
+                                    root,
+                                    context,
+                                    info,
+                                    argsFromKeys: (keys) => {
+                                        const args = {};
+                                        dset(args, additionalResolver.keysArg, keys);
+                                        Object.assign(args, targetArgs);
+                                        return args;
+                                    },
+                                    key: lodashGet(root, additionalResolver.keyField),
+                                };
+                                return context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName](options);
+                            },
+                        },
+                    },
+                };
+            }
+            else if ('targetTypeName' in additionalResolver) {
+                return {
+                    [additionalResolver.targetTypeName]: {
+                        [additionalResolver.targetFieldName]: {
+                            selectionSet: additionalResolver.requiredSelectionSet,
+                            resolve: (root, args, context, info) => {
+                                // Assert source exists
+                                if (!context[additionalResolver.sourceName]) {
+                                    throw new Error(`No source found named "${additionalResolver.sourceName}"`);
+                                }
+                                if (!context[additionalResolver.sourceName][additionalResolver.sourceTypeName]) {
+                                    throw new Error(`No root type found named "${additionalResolver.sourceTypeName}" exists in the source ${additionalResolver.sourceName}\n` +
+                                        `It should be one of the following; ${Object.keys(context[additionalResolver.sourceName]).join(',')})}}`);
+                                }
+                                if (!context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName]) {
+                                    throw new Error(`No field named "${additionalResolver.sourceFieldName}" exists in the type ${additionalResolver.sourceTypeName} from the source ${additionalResolver.sourceName}`);
+                                }
+                                if (!baseOptions.selectionSet) {
+                                    baseOptions.selectionSet = generateSelectionSetFactory(info.schema, additionalResolver);
+                                }
+                                const resolverData = { root, args, context, info, env: process.env };
+                                const targetArgs = {};
+                                for (const argPath in additionalResolver.sourceArgs) {
+                                    dset(targetArgs, argPath, stringInterpolator.parse(additionalResolver.sourceArgs[argPath].toString(), resolverData));
+                                }
+                                const options = {
+                                    ...baseOptions,
+                                    root,
+                                    args: targetArgs,
+                                    context,
+                                    info,
+                                };
+                                return context[additionalResolver.sourceName][additionalResolver.sourceTypeName][additionalResolver.sourceFieldName](options);
+                            },
+                        },
+                    },
+                };
+            }
+            else {
+                return additionalResolver;
+            }
+        }
+    }));
+}

package/esm/sanitize-name-for-graphql.js

@@ -0,0 +1,91 @@
+const reservedNames = ['Query', 'Mutation', 'Subscription', 'File'];
+const KNOWN_CHARACTERS = {
+    '+': 'PLUS',
+    '-': 'MINUS',
+    '>': 'GREATER_THAN',
+    '<': 'LESS_THAN',
+    '=': 'EQUALS',
+    '&': 'AMPERSAND',
+    '|': 'PIPE',
+    '@': 'AT',
+    '*': 'STAR',
+    ':': 'COLON',
+    '{': 'LEFT_CURLY_BRACE',
+    '}': 'RIGHT_CURLY_BRACE',
+    '[': 'LEFT_SQUARE_BRACE',
+    ']': 'RIGHT_SQUARE_BRACE',
+    ',': 'COMMA',
+    '%': 'PERCENT',
+    $: 'DOLLAR',
+    '#': 'POUND',
+    '^': 'CARET',
+    '~': 'TILDE',
+    '?': 'QUESTION_MARK',
+    '!': 'EXCLAMATION_MARK',
+    '"': 'QUOTATION_MARK',
+    "'": 'SINGLE_QUOTE',
+    '\\': 'BACKSLASH',
+    '/': 'SLASH',
+    '.': 'DOT',
+    '`': 'BACKTICK',
+    ';': 'SEMICOLON',
+    '(': 'LEFT_PARENTHESIS',
+    ')': 'RIGHT_PARENTHESIS',
+};
+function getKnownCharacterOrCharCode(ch) {
+    return KNOWN_CHARACTERS[ch] || ch.charCodeAt(0).toString();
+}
+export function removeClosedBrackets(val) {
+    let out = val;
+    for (;;) {
+        // finds the first and shortest closed bracket match, starting from the left
+        const match = out.match(/\(.+?\)/);
+        const yesbrack = match === null || match === void 0 ? void 0 : match[0];
+        if (!yesbrack) {
+            break;
+        }
+        // remove the brackets
+        const nobrack = yesbrack.substring(1, yesbrack.length - 1);
+        // replace the match removing bracks, just once starting from the left
+        out = out.replace(yesbrack, nobrack);
+    }
+    return out;
+}
+export function sanitizeNameForGraphQL(unsafeName) {
+    let sanitizedName = unsafeName.trim();
+    sanitizedName = removeClosedBrackets(sanitizedName);
+    if (!isNaN(parseInt(sanitizedName))) {
+        if (sanitizedName.startsWith('-')) {
+            sanitizedName = sanitizedName.replace('-', 'NEGATIVE_');
+        }
+        else {
+            sanitizedName = '_' + sanitizedName;
+        }
+    }
+    if (!/^[_a-zA-Z0-9]*$/.test(sanitizedName)) {
+        const unsanitizedName = sanitizedName;
+        sanitizedName = '';
+        for (const ch of unsanitizedName) {
+            if (/^[_a-zA-Z0-9]$/.test(ch)) {
+                sanitizedName += ch;
+            }
+            else if (ch === ' ' || ch === '-' || ch === '.' || ch === '/' || ch === ':') {
+                sanitizedName += '_';
+            }
+            else {
+                sanitizedName += `_${getKnownCharacterOrCharCode(ch)}_`;
+            }
+        }
+    }
+    // Names cannot start with __
+    if (sanitizedName.startsWith('__')) {
+        sanitizedName = sanitizedName.replace('__', '_0');
+    }
+    if (reservedNames.includes(sanitizedName)) {
+        sanitizedName += '_';
+    }
+    if (sanitizedName.length === 0) {
+        return '_';
+    }
+    return sanitizedName;
+}

package/esm/with-cancel.js

@@ -0,0 +1,30 @@
+export function withCancel(asyncIterable, onCancel) {
+    return new Proxy(asyncIterable, {
+        get(asyncIterable, prop) {
+            if (prop === Symbol.asyncIterator) {
+                return function getIteratorWithCancel() {
+                    const asyncIterator = asyncIterable[Symbol.asyncIterator]();
+                    return {
+                        next: asyncIterator.next ? (...args) => asyncIterator.next(...args) : undefined,
+                        return: async (...args) => {
+                            onCancel();
+                            if (asyncIterator.return) {
+                                return asyncIterator.return(...args);
+                            }
+                            return {
+                                value: undefined,
+                                done: true,
+                            };
+                        },
+                        throw: asyncIterator.throw ? (...args) => asyncIterator.throw(...args) : undefined,
+                    };
+                };
+            }
+            const propVal = asyncIterable[prop];
+            if (typeof propVal === 'function') {
+                return propVal.bind(asyncIterable);
+            }
+            return propVal;
+        },
+    });
+}

package/esm/with-cookies.js

@@ -0,0 +1,14 @@
+// withCookies - embeds cookies object into the request
+export const withCookies = (request) => {
+    request.cookies = {};
+    try {
+        request.cookies = (request.headers.get('Cookie') || '')
+            .split(/;\s*/)
+            .map(pair => pair.split(/=(.+)/))
+            .reduce((acc, [key, value]) => {
+            acc[key] = value;
+            return acc;
+        }, {});
+    }
+    catch (err) { }
+};

package/esm/with-filter.js

@@ -0,0 +1,49 @@
+export function withFilter(asyncIteratorFn, filterFn) {
+    return async (rootValue, args, context, info) => {
+        const asyncIterator = await asyncIteratorFn(rootValue, args, context, info);
+        const getNextPromise = () => {
+            return new Promise((resolve, reject) => {
+                const inner = () => {
+                    asyncIterator
+                        .next()
+                        .then(payload => {
+                        if (payload.done === true) {
+                            resolve(payload);
+                            return;
+                        }
+                        Promise.resolve(filterFn(payload.value, args, context, info))
+                            .catch(() => false) // We ignore errors from filter function
+                            .then(filterResult => {
+                            if (filterResult === true) {
+                                resolve(payload);
+                                return;
+                            }
+                            // Skip the current value and wait for the next one
+                            inner();
+                        })
+                            .catch(() => false); // We ignore errors from filter function;
+                    })
+                        .catch(err => {
+                        reject(err);
+                    });
+                };
+                inner();
+            });
+        };
+        const asyncIterator2 = {
+            next() {
+                return getNextPromise();
+            },
+            return() {
+                return asyncIterator.return();
+            },
+            throw(error) {
+                return asyncIterator.throw(error);
+            },
+            [Symbol.asyncIterator]() {
+                return this;
+            },
+        };
+        return asyncIterator2;
+    };
+}