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

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

@@ -0,0 +1,132 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.readUrl = exports.readFile = exports.loadYaml = exports.readFileOrUrl = exports.isUrl = void 0;
+const js_yaml_1 = require("js-yaml");
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const load_from_module_export_expression_js_1 = require("./load-from-module-export-expression.js");
+function isUrl(str) {
+    return /^https?:\/\//.test(str);
+}
+exports.isUrl = isUrl;
+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);
+    }
+}
+exports.readFileOrUrl = readFileOrUrl;
+function getSchema(filepath, logger) {
+    return js_yaml_1.DEFAULT_SCHEMA.extend([
+        new js_yaml_1.Type('!include', {
+            kind: 'scalar',
+            resolve(path) {
+                return typeof path === 'string';
+            },
+            construct(path) {
+                const newCwd = cross_helpers_1.path.dirname(filepath);
+                const absoluteFilePath = cross_helpers_1.path.isAbsolute(path)
+                    ? path
+                    : cross_helpers_1.path.resolve(newCwd, path);
+                const content = cross_helpers_1.fs.readFileSync(absoluteFilePath, 'utf8');
+                return loadYaml(absoluteFilePath, content, logger);
+            },
+        }),
+        new js_yaml_1.Type('!includes', {
+            kind: 'scalar',
+            resolve(path) {
+                return typeof path === 'string';
+            },
+            construct(path) {
+                const newCwd = cross_helpers_1.path.dirname(filepath);
+                const absoluteDirPath = cross_helpers_1.path.isAbsolute(path)
+                    ? path
+                    : cross_helpers_1.path.resolve(newCwd, path);
+                const files = cross_helpers_1.fs.readdirSync(absoluteDirPath);
+                return files.map(filePath => {
+                    const absoluteFilePath = cross_helpers_1.path.resolve(absoluteDirPath, filePath);
+                    const fileContent = cross_helpers_1.fs.readFileSync(absoluteFilePath, 'utf8');
+                    return loadYaml(absoluteFilePath, fileContent, logger);
+                });
+            },
+        }),
+    ]);
+}
+function loadYaml(filepath, content, logger) {
+    return (0, js_yaml_1.load)(content, {
+        filename: filepath,
+        schema: getSchema(filepath, logger),
+        onWarning(warning) {
+            logger.warn(`${filepath}: ${warning.message}\n${warning.stack}`);
+        },
+    });
+}
+exports.loadYaml = loadYaml;
+async function readFile(fileExpression, { allowUnknownExtensions, cwd, fallbackFormat, importFn, logger }) {
+    const [filePath] = fileExpression.split('#');
+    if (/js$/.test(filePath) || /ts$/.test(filePath)) {
+        return (0, load_from_module_export_expression_js_1.loadFromModuleExportExpression)(fileExpression, {
+            cwd,
+            importFn,
+            defaultExportName: 'default',
+        });
+    }
+    const actualPath = cross_helpers_1.path.isAbsolute(filePath) ? filePath : cross_helpers_1.path.join(cwd, filePath);
+    const rawResult = await cross_helpers_1.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;
+}
+exports.readFile = readFile;
+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;
+}
+exports.readUrl = readUrl;

package/cjs/resolve-additional-resolvers.js

@@ -0,0 +1,350 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveAdditionalResolvers = exports.resolveAdditionalResolversWithoutImport = void 0;
+const tslib_1 = require("tslib");
+const dset_1 = require("dset");
+const graphql_1 = require("graphql");
+const lodash_get_1 = tslib_1.__importDefault(require("lodash.get"));
+const lodash_topath_1 = tslib_1.__importDefault(require("lodash.topath"));
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const string_interpolation_1 = require("@graphql-mesh/string-interpolation");
+const utils_1 = require("@graphql-tools/utils");
+const load_from_module_export_expression_js_1 = require("./load-from-module-export-expression.js");
+const with_filter_js_1 = require("./with-filter.js");
+function getTypeByPath(type, path) {
+    if ('ofType' in type) {
+        return getTypeByPath((0, graphql_1.getNamedType)(type), path);
+    }
+    if (path.length === 0) {
+        return (0, graphql_1.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 () => (0, utils_1.parseSelectionSet)(additionalResolver.sourceSelectionSet);
+        // If result path provided without a selectionSet
+    }
+    else if (additionalResolver.result) {
+        const resultPath = (0, lodash_topath_1.default)(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 ((0, graphql_1.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 = (0, graphql_1.getNamedType)(targetField.type);
+                abstractResultTypeName = targetFieldType === null || targetFieldType === void 0 ? void 0 : targetFieldType.name;
+            }
+            if (abstractResultTypeName !== resultFieldType.name) {
+                const abstractResultType = schema.getType(abstractResultTypeName);
+                if (((0, graphql_1.isInterfaceType)(abstractResultType) || (0, graphql_1.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: graphql_1.Kind.SELECTION_SET,
+                            selections: [
+                                {
+                                    kind: graphql_1.Kind.INLINE_FRAGMENT,
+                                    typeCondition: {
+                                        kind: graphql_1.Kind.NAMED_TYPE,
+                                        name: {
+                                            kind: graphql_1.Kind.NAME,
+                                            value: abstractResultTypeName,
+                                        },
+                                    },
+                                    selectionSet: finalSelectionSet,
+                                },
+                            ],
+                        };
+                    }
+                    finalSelectionSet = {
+                        kind: graphql_1.Kind.SELECTION_SET,
+                        selections: [
+                            {
+                                // we create a wrapping AST Field
+                                kind: graphql_1.Kind.FIELD,
+                                name: {
+                                    kind: graphql_1.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 (0, lodash_get_1.default)(result, resultExpression);
+    };
+}
+function resolveAdditionalResolversWithoutImport(additionalResolver, pubsub) {
+    const baseOptions = {};
+    if (additionalResolver.result) {
+        baseOptions.valuesFromResults = generateValuesFromResults(additionalResolver.result);
+    }
+    if ('pubsubTopic' in additionalResolver) {
+        return {
+            [additionalResolver.targetTypeName]: {
+                [additionalResolver.targetFieldName]: {
+                    subscribe: (0, with_filter_js_1.withFilter)((root, args, context, info) => {
+                        const resolverData = { root, args, context, info, env: cross_helpers_1.process.env };
+                        const topic = string_interpolation_1.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: cross_helpers_1.process.env };
+                        const targetArgs = {};
+                        for (const argPath in additionalResolver.additionalArgs || {}) {
+                            (0, dset_1.dset)(targetArgs, argPath, string_interpolation_1.stringInterpolator.parse(additionalResolver.additionalArgs[argPath], resolverData));
+                        }
+                        const options = {
+                            ...baseOptions,
+                            root,
+                            context,
+                            info,
+                            argsFromKeys: (keys) => {
+                                const args = {};
+                                (0, dset_1.dset)(args, additionalResolver.keysArg, keys);
+                                Object.assign(args, targetArgs);
+                                return args;
+                            },
+                            key: (0, lodash_get_1.default)(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: cross_helpers_1.process.env };
+                        const targetArgs = {};
+                        for (const argPath in additionalResolver.sourceArgs) {
+                            (0, dset_1.dset)(targetArgs, argPath, string_interpolation_1.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;
+    }
+}
+exports.resolveAdditionalResolversWithoutImport = resolveAdditionalResolversWithoutImport;
+function resolveAdditionalResolvers(baseDir, additionalResolvers, importFn, pubsub) {
+    return Promise.all((additionalResolvers || []).map(async (additionalResolver) => {
+        if (typeof additionalResolver === 'string') {
+            const resolvers = await (0, load_from_module_export_expression_js_1.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: (0, with_filter_js_1.withFilter)((root, args, context, info) => {
+                                const resolverData = { root, args, context, info, env: cross_helpers_1.process.env };
+                                const topic = string_interpolation_1.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: cross_helpers_1.process.env };
+                                const targetArgs = {};
+                                for (const argPath in additionalResolver.additionalArgs || {}) {
+                                    (0, dset_1.dset)(targetArgs, argPath, string_interpolation_1.stringInterpolator.parse(additionalResolver.additionalArgs[argPath], resolverData));
+                                }
+                                const options = {
+                                    ...baseOptions,
+                                    root,
+                                    context,
+                                    info,
+                                    argsFromKeys: (keys) => {
+                                        const args = {};
+                                        (0, dset_1.dset)(args, additionalResolver.keysArg, keys);
+                                        Object.assign(args, targetArgs);
+                                        return args;
+                                    },
+                                    key: (0, lodash_get_1.default)(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: cross_helpers_1.process.env };
+                                const targetArgs = {};
+                                for (const argPath in additionalResolver.sourceArgs) {
+                                    (0, dset_1.dset)(targetArgs, argPath, string_interpolation_1.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;
+            }
+        }
+    }));
+}
+exports.resolveAdditionalResolvers = resolveAdditionalResolvers;

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

@@ -0,0 +1,96 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sanitizeNameForGraphQL = exports.removeClosedBrackets = void 0;
+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();
+}
+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;
+}
+exports.removeClosedBrackets = removeClosedBrackets;
+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;
+}
+exports.sanitizeNameForGraphQL = sanitizeNameForGraphQL;

package/cjs/with-cancel.js

@@ -0,0 +1,34 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCancel = void 0;
+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;
+        },
+    });
+}
+exports.withCancel = withCancel;

package/cjs/with-cookies.js

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.withCookies = void 0;
+// withCookies - embeds cookies object into the request
+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) { }
+};
+exports.withCookies = withCookies;