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

package/cjs/with-filter.js

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

package/esm/apply-transforms.js

@@ -0,0 +1,29 @@
+export function applySchemaTransforms(originalWrappingSchema, subschemaConfig, transformedSchema, transforms) {
+    if (transforms === null || transforms === void 0 ? void 0 : transforms.length) {
+        return transforms.reduce((schema, transform) => 'transformSchema' in transform
+            ? transform.transformSchema(schema, subschemaConfig)
+            : schema, originalWrappingSchema);
+    }
+    return originalWrappingSchema;
+}
+export function applyRequestTransforms(originalRequest, delegationContext, transformationContext, transforms) {
+    transformationContext.contextMap = transformationContext.contextMap || new WeakMap();
+    const contextMap = transformationContext.contextMap;
+    transforms === null || transforms === void 0 ? void 0 : transforms.forEach(transform => {
+        if (!contextMap.has(transform)) {
+            contextMap.set(transform, {
+                nextIndex: 0,
+                paths: {},
+            });
+        }
+    });
+    return transforms.reduceRight((request, transform) => 'transformRequest' in transform
+        ? transform.transformRequest(request, delegationContext, contextMap.get(transform))
+        : request, originalRequest);
+}
+export function applyResultTransforms(originalResult, delegationContext, transformationContext, transforms) {
+    const contextMap = transformationContext.contextMap;
+    return transforms.reduce((result, transform) => 'transformResult' in transform
+        ? transform.transformResult(result, delegationContext, contextMap.get(transform))
+        : result, originalResult);
+}

package/esm/defaultImportFn.js

@@ -0,0 +1,32 @@
+import { path as pathModule } from '@graphql-mesh/cross-helpers';
+async function defaultImportFn(path) {
+    let module = await import(/* @vite-ignore */ path)
+        .catch(e => {
+        if (e.code === 'ERR_REQUIRE_ESM') {
+            // eslint-disable-next-line no-new-func
+            return new Function(`return import(${JSON.stringify(path)})`)();
+        }
+        throw e;
+    })
+        .catch(e => {
+        if (pathModule.isAbsolute(path) && !path.endsWith('.js') && !path.endsWith('.ts')) {
+            return defaultImportFn(`${path}.ts`);
+        }
+        throw e;
+    });
+    if (module.default != null) {
+        module = module.default;
+    }
+    if (typeof module === 'object' && module != null) {
+        const prototypeOfObject = Object.getPrototypeOf(module);
+        if (prototypeOfObject == null || prototypeOfObject === Object.prototype) {
+            const normalizedVal = {};
+            for (const key in module) {
+                normalizedVal[key] = module[key];
+            }
+            return normalizedVal;
+        }
+    }
+    return module;
+}
+export { defaultImportFn };

package/esm/extract-resolvers.js

@@ -0,0 +1,19 @@
+import { getResolversFromSchema } from '@graphql-tools/utils';
+export function extractResolvers(schema) {
+    const allResolvers = getResolversFromSchema(schema);
+    const filteredResolvers = {};
+    for (const prop in allResolvers) {
+        if (!prop.startsWith('_')) {
+            filteredResolvers[prop] = allResolvers[prop];
+        }
+        if (typeof filteredResolvers === 'object') {
+            for (const fieldName in filteredResolvers[prop]) {
+                if (!prop.startsWith('_resolveType')) {
+                    filteredResolvers[prop][fieldName] =
+                        allResolvers[prop][fieldName];
+                }
+            }
+        }
+    }
+    return filteredResolvers;
+}

package/esm/fileURLToPath.js

@@ -0,0 +1,46 @@
+import { path as pathModule } from '@graphql-mesh/cross-helpers';
+function fileUriToPath(uri) {
+    if (typeof uri !== 'string' || uri.length <= 7 || uri.substring(0, 7) !== 'file://') {
+        throw new TypeError('must pass in a file:// URI to convert to a file path');
+    }
+    const rest = decodeURI(uri.substring(7));
+    const firstSlash = rest.indexOf('/');
+    let host = rest.substring(0, firstSlash);
+    let path = rest.substring(firstSlash + 1);
+    // 2.  Scheme Definition
+    // As a special case, <host> can be the string "localhost" or the empty
+    // string; this is interpreted as "the machine from which the URL is
+    // being interpreted".
+    if (host === 'localhost') {
+        host = '';
+    }
+    if (host) {
+        host = pathModule.sep + pathModule.sep + host;
+    }
+    // 3.2  Drives, drive letters, mount points, file system root
+    // Drive letters are mapped into the top of a file URI in various ways,
+    // depending on the implementation; some applications substitute
+    // vertical bar ("|") for the colon after the drive letter, yielding
+    // "file:///c|/tmp/test.txt".  In some cases, the colon is left
+    // unchanged, as in "file:///c:/tmp/test.txt".  In other cases, the
+    // colon is simply omitted, as in "file:///c/tmp/test.txt".
+    path = path.replace(/^(.+)\|/, '$1:');
+    // for Windows, we need to invert the path separators from what a URI uses
+    if (pathModule.sep === '\\') {
+        path = path.replace(/\//g, '\\');
+    }
+    if (/^.+:/.test(path)) {
+        // has Windows drive at beginning of path
+    }
+    else {
+        // unix path…
+        path = pathModule.sep + path;
+    }
+    return host + path;
+}
+export function fileURLToPath(url) {
+    if (url === null || url === void 0 ? void 0 : url.startsWith('file://')) {
+        return fileUriToPath(url);
+    }
+    return url || '';
+}

package/esm/fs-operations.js

@@ -0,0 +1,57 @@
+import { fs, path as pathModule } from '@graphql-mesh/cross-helpers';
+export async function pathExists(path) {
+    if (!path) {
+        return false;
+    }
+    try {
+        await fs.promises.stat(path);
+        return true;
+    }
+    catch (e) {
+        if (e.toString().includes('ENOENT')) {
+            return false;
+        }
+        else {
+            throw e;
+        }
+    }
+}
+export function writeJSON(path, data, replacer, space) {
+    const stringified = JSON.stringify(data, replacer, space);
+    return writeFile(path, stringified, 'utf-8');
+}
+export const writeFile = async (path, ...args) => {
+    if (typeof path === 'string') {
+        const containingDir = pathModule.dirname(path);
+        if (!(await pathExists(containingDir))) {
+            await mkdir(containingDir);
+        }
+    }
+    return fs.promises.writeFile(path, ...args);
+};
+export async function mkdir(path, options = { recursive: true }) {
+    const ifExists = await pathExists(path);
+    if (!ifExists) {
+        await fs.promises.mkdir(path, options);
+    }
+}
+export async function rmdirs(dir) {
+    if (await pathExists(dir)) {
+        const entries = await fs.promises.readdir(dir, { withFileTypes: true });
+        const results = await Promise.allSettled(entries.map(entry => {
+            const fullPath = pathModule.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                return rmdirs(fullPath);
+            }
+            else {
+                return fs.promises.unlink(fullPath);
+            }
+        }));
+        for (const result of results) {
+            if (result.status === 'rejected' && result.reason.code !== 'ENOENT') {
+                throw result.reason;
+            }
+        }
+        await fs.promises.rmdir(dir);
+    }
+}

package/esm/getHeadersObj.js

@@ -0,0 +1,57 @@
+function headersToJSON(headers) {
+    return Object.fromEntries(headers.entries());
+}
+function isHeaders(headers) {
+    return headers != null && 'get' in headers && typeof headers.get === 'function';
+}
+export function getHeadersObj(headers) {
+    if (headers == null || !isHeaders(headers)) {
+        return headers;
+    }
+    return new Proxy({}, {
+        get(_target, name) {
+            if (name === 'toJSON') {
+                return () => headersToJSON(headers);
+            }
+            return headers.get(name.toString().toLowerCase()) || undefined;
+        },
+        has(_target, name) {
+            if (name === 'toJSON') {
+                return true;
+            }
+            return headers.has(name.toString().toLowerCase());
+        },
+        ownKeys(_target) {
+            return [...headers.keys()];
+        },
+        set(_target, name, value) {
+            headers.set(name.toString().toLowerCase(), value);
+            return true;
+        },
+        defineProperty(_target, name, descriptor) {
+            if (descriptor.value != null) {
+                headers.set(name.toString().toLowerCase(), descriptor.value);
+            }
+            return true;
+        },
+        getOwnPropertyDescriptor(_target, name) {
+            const value = headers.get(name.toString().toLowerCase());
+            if (value == null) {
+                return undefined;
+            }
+            return {
+                configurable: true,
+                enumerable: true,
+                value,
+                writable: true,
+            };
+        },
+        deleteProperty(_target, name) {
+            headers.delete(name.toString().toLowerCase());
+            return true;
+        },
+        preventExtensions() {
+            return true;
+        },
+    });
+}

package/esm/global-lru-cache.js

@@ -0,0 +1,4 @@
+import lru from 'tiny-lru';
+export function createLruCache(max, ttl) {
+    return lru(max, ttl);
+}

package/esm/group-transforms.js

@@ -0,0 +1,13 @@
+export function groupTransforms(transforms) {
+    const wrapTransforms = [];
+    const noWrapTransforms = [];
+    transforms === null || transforms === void 0 ? void 0 : transforms.forEach(transform => {
+        if (transform.noWrap) {
+            noWrapTransforms.push(transform);
+        }
+        else {
+            wrapTransforms.push(transform);
+        }
+    });
+    return { wrapTransforms, noWrapTransforms };
+}

package/esm/index.js

@@ -0,0 +1,17 @@
+export * from './read-file-or-url.js';
+export * from './load-from-module-export-expression.js';
+export * from './with-cancel.js';
+export * from './extract-resolvers.js';
+export * from './group-transforms.js';
+export * from './apply-transforms.js';
+export * from './fs-operations.js';
+export * from './global-lru-cache.js';
+export * from './sanitize-name-for-graphql.js';
+export * from './resolve-additional-resolvers.js';
+export * from './logger.js';
+export * from './parseAndPrintWithCache.js';
+export * from './defaultImportFn.js';
+export * from './pubsub.js';
+export * from './fileURLToPath.js';
+export * from './getHeadersObj.js';
+export * from './with-cookies.js';

package/esm/load-from-module-export-expression.js

@@ -0,0 +1,25 @@
+/* eslint-disable @typescript-eslint/return-await */
+import { path } from '@graphql-mesh/cross-helpers';
+import { defaultImportFn } from './defaultImportFn.js';
+export async function loadFromModuleExportExpression(expression, options) {
+    if (typeof expression !== 'string') {
+        return Promise.resolve(expression);
+    }
+    const { defaultExportName, cwd, importFn = defaultImportFn } = options || {};
+    const [modulePath, exportName = defaultExportName] = expression.split('#');
+    const mod = await tryImport(modulePath, cwd, importFn);
+    return mod[exportName] || (mod.default && mod.default[exportName]) || mod.default || mod;
+}
+async function tryImport(modulePath, cwd, importFn) {
+    try {
+        return await importFn(modulePath);
+    }
+    catch (_a) {
+        if (!path.isAbsolute(modulePath)) {
+            const absoluteModulePath = path.isAbsolute(modulePath)
+                ? modulePath
+                : path.join(cwd, modulePath);
+            return importFn(absoluteModulePath);
+        }
+    }
+}

package/esm/logger.js

@@ -0,0 +1,118 @@
+import { process, util } from '@graphql-mesh/cross-helpers';
+const ANSI_CODES = {
+    black: '\x1b[30m',
+    red: '\x1b[31m',
+    green: '\x1b[32m',
+    yellow: '\x1b[33m',
+    blue: '\x1b[34m',
+    magenta: '\x1b[35m',
+    cyan: '\x1b[36m',
+    white: '\x1b[37m',
+    reset: '\x1b[0m',
+    bold: '\x1b[1m',
+    orange: '\x1b[48:5:166m',
+};
+export const warnColor = msg => ANSI_CODES.orange + msg + ANSI_CODES.reset;
+export const infoColor = msg => ANSI_CODES.cyan + msg + ANSI_CODES.reset;
+export const errorColor = msg => ANSI_CODES.red + msg + ANSI_CODES.reset;
+export const debugColor = msg => ANSI_CODES.magenta + msg + ANSI_CODES.reset;
+export const titleBold = msg => ANSI_CODES.bold + msg + ANSI_CODES.reset;
+export class DefaultLogger {
+    constructor(name) {
+        this.name = name;
+    }
+    getLoggerMessage({ args = [], trim = !this.isDebug }) {
+        return args
+            .flat(Infinity)
+            .map(arg => {
+            if (typeof arg === 'string') {
+                if (trim && arg.length > 100) {
+                    return (arg.slice(0, 100) +
+                        '...' +
+                        '<Error message is too long. Enable DEBUG=1 to see the full message.>');
+                }
+                return arg;
+            }
+            else if (typeof arg === 'object' && (arg === null || arg === void 0 ? void 0 : arg.stack) != null) {
+                return arg.stack;
+            }
+            return util.inspect(arg);
+        })
+            .join(` `);
+    }
+    handleLazyMessage({ lazyArgs, trim }) {
+        const flattenedArgs = lazyArgs.flat(Infinity).flatMap(arg => {
+            if (typeof arg === 'function') {
+                return arg();
+            }
+            return arg;
+        });
+        return this.getLoggerMessage({
+            args: flattenedArgs,
+            trim,
+        });
+    }
+    get isDebug() {
+        return (process.env.DEBUG === '1' ||
+            globalThis.DEBUG === '1' ||
+            this.name.includes(process.env.DEBUG || globalThis.DEBUG));
+    }
+    get prefix() {
+        return this.name ? titleBold(this.name) : ``;
+    }
+    log(...args) {
+        const message = this.getLoggerMessage({
+            args,
+        });
+        return console.log(`${this.prefix} ${message}`);
+    }
+    warn(...args) {
+        const message = this.getLoggerMessage({
+            args,
+        });
+        const fullMessage = `⚠️ ${this.prefix} ${warnColor(message)}`;
+        if (console.warn) {
+            console.warn(fullMessage);
+        }
+        else {
+            console.log(fullMessage);
+        }
+    }
+    info(...args) {
+        const message = this.getLoggerMessage({
+            args,
+        });
+        const fullMessage = `💡 ${this.prefix} ${infoColor(message)}`;
+        if (console.info) {
+            console.info(fullMessage);
+        }
+        else {
+            console.log(fullMessage);
+        }
+    }
+    error(...args) {
+        const message = this.getLoggerMessage({
+            args,
+            trim: false,
+        });
+        const fullMessage = `💥 ${this.prefix} ${errorColor(message)}`;
+        console.log(fullMessage);
+    }
+    debug(...lazyArgs) {
+        if (this.isDebug) {
+            const message = this.handleLazyMessage({
+                lazyArgs,
+            });
+            const fullMessage = `🐛 ${this.prefix} ${debugColor(message)}`;
+            if (console.debug) {
+                console.debug(fullMessage);
+            }
+            else {
+                console.log(fullMessage);
+            }
+        }
+    }
+    child(name) {
+        return new DefaultLogger(this.name ? `${this.name} - ${name}` : name);
+    }
+}

package/esm/parseAndPrintWithCache.js

@@ -0,0 +1,37 @@
+import { parse, print } from 'graphql';
+import { memoize1 } from '@graphql-tools/utils';
+import { createLruCache } from './global-lru-cache.js';
+const parseCache = createLruCache(1000, 3600);
+const printCache = createLruCache(1000, 3600);
+export function parseWithCache(sdl) {
+    const trimmedSdl = sdl.trim();
+    let document = parseCache.get(trimmedSdl);
+    if (!document) {
+        document = parse(trimmedSdl, { noLocation: true });
+        parseCache.set(trimmedSdl, document);
+        printCache.set(JSON.stringify(document), trimmedSdl);
+    }
+    return document;
+}
+export const printWithCache = memoize1(function printWithCache(document) {
+    const stringifedDocumentJson = JSON.stringify(document);
+    let sdl = printCache.get(stringifedDocumentJson);
+    if (!sdl) {
+        sdl = print(document).trim();
+        printCache.set(stringifedDocumentJson, sdl);
+        parseCache.set(sdl, document);
+    }
+    return sdl;
+});
+export function gql([sdl], ...args) {
+    let result = sdl;
+    for (const arg of args || []) {
+        if (typeof arg === 'string') {
+            result += arg;
+        }
+        else {
+            result += printWithCache(arg);
+        }
+    }
+    return parseWithCache(result);
+}

package/esm/pubsub.js

@@ -0,0 +1,53 @@
+import { observableToAsyncIterable } from '@graphql-tools/utils';
+export class PubSub {
+    constructor() {
+        this.subIdListenerMap = new Map();
+        this.listenerEventMap = new Map();
+        this.eventNameListenersMap = new Map();
+    }
+    getEventNames() {
+        return this.eventNameListenersMap.keys();
+    }
+    publish(triggerName, detail) {
+        const eventNameListeners = this.eventNameListenersMap.get(triggerName);
+        if (eventNameListeners) {
+            Promise.allSettled([...eventNameListeners].map(listener => listener(detail))).catch(e => console.error(e));
+        }
+    }
+    subscribe(triggerName, onMessage) {
+        let eventNameListeners = this.eventNameListenersMap.get(triggerName);
+        if (!eventNameListeners) {
+            eventNameListeners = new Set();
+            this.eventNameListenersMap.set(triggerName, eventNameListeners);
+        }
+        const subId = Date.now();
+        eventNameListeners.add(onMessage);
+        this.subIdListenerMap.set(subId, onMessage);
+        this.listenerEventMap.set(onMessage, triggerName);
+        return subId;
+    }
+    unsubscribe(subId) {
+        const listener = this.subIdListenerMap.get(subId);
+        if (listener) {
+            this.subIdListenerMap.delete(subId);
+            const eventName = this.listenerEventMap.get(listener);
+            if (eventName) {
+                const eventNameListeners = this.eventNameListenersMap.get(eventName);
+                if (eventNameListeners) {
+                    eventNameListeners.delete(listener);
+                }
+            }
+        }
+        this.listenerEventMap.delete(listener);
+    }
+    asyncIterator(triggerName) {
+        return observableToAsyncIterable({
+            subscribe: observer => {
+                const subId = this.subscribe(triggerName, data => observer.next(data));
+                return {
+                    unsubscribe: () => this.unsubscribe(subId),
+                };
+            },
+        });
+    }
+}