@graphql-mesh/utils 1.0.0-alpha-20220804093904-8e2e41f7f → 1.0.0-alpha-20230420220344-25b6b92bf

package/cjs/apply-transforms.js

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

package/cjs/defaultImportFn.js

@@ -0,0 +1,57 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.defaultImportFn = void 0;
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+async function defaultImportFn(path) {
+    let module = await Promise.resolve(`${path}`).then(s => __importStar(require(s))).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 (cross_helpers_1.path.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;
+}
+exports.defaultImportFn = defaultImportFn;

package/cjs/extract-resolvers.js

@@ -0,0 +1,23 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.extractResolvers = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function extractResolvers(schema) {
+    const allResolvers = (0, utils_1.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;
+}
+exports.extractResolvers = extractResolvers;

package/cjs/fileURLToPath.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.fileURLToPath = void 0;
+const cross_helpers_1 = require("@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 = cross_helpers_1.path.sep + cross_helpers_1.path.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 (cross_helpers_1.path.sep === '\\') {
+        path = path.replace(/\//g, '\\');
+    }
+    if (/^.+:/.test(path)) {
+        // has Windows drive at beginning of path
+    }
+    else {
+        // unix path…
+        path = cross_helpers_1.path.sep + path;
+    }
+    return host + path;
+}
+function fileURLToPath(url) {
+    if (url === null || url === void 0 ? void 0 : url.startsWith('file://')) {
+        return fileUriToPath(url);
+    }
+    return url || '';
+}
+exports.fileURLToPath = fileURLToPath;

package/cjs/fs-operations.js

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

package/cjs/getHeadersObj.js

@@ -0,0 +1,61 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getHeadersObj = void 0;
+function headersToJSON(headers) {
+    return Object.fromEntries(headers.entries());
+}
+function isHeaders(headers) {
+    return headers != null && 'get' in headers && typeof headers.get === 'function';
+}
+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;
+        },
+    });
+}
+exports.getHeadersObj = getHeadersObj;

package/cjs/global-lru-cache.js

@@ -0,0 +1,9 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createLruCache = void 0;
+const tslib_1 = require("tslib");
+const tiny_lru_1 = tslib_1.__importDefault(require("tiny-lru"));
+function createLruCache(max, ttl) {
+    return (0, tiny_lru_1.default)(max, ttl);
+}
+exports.createLruCache = createLruCache;

package/cjs/group-transforms.js

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

package/cjs/index.js

@@ -0,0 +1,20 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+const tslib_1 = require("tslib");
+tslib_1.__exportStar(require("./read-file-or-url.js"), exports);
+tslib_1.__exportStar(require("./load-from-module-export-expression.js"), exports);
+tslib_1.__exportStar(require("./with-cancel.js"), exports);
+tslib_1.__exportStar(require("./extract-resolvers.js"), exports);
+tslib_1.__exportStar(require("./group-transforms.js"), exports);
+tslib_1.__exportStar(require("./apply-transforms.js"), exports);
+tslib_1.__exportStar(require("./fs-operations.js"), exports);
+tslib_1.__exportStar(require("./global-lru-cache.js"), exports);
+tslib_1.__exportStar(require("./sanitize-name-for-graphql.js"), exports);
+tslib_1.__exportStar(require("./resolve-additional-resolvers.js"), exports);
+tslib_1.__exportStar(require("./logger.js"), exports);
+tslib_1.__exportStar(require("./parseAndPrintWithCache.js"), exports);
+tslib_1.__exportStar(require("./defaultImportFn.js"), exports);
+tslib_1.__exportStar(require("./pubsub.js"), exports);
+tslib_1.__exportStar(require("./fileURLToPath.js"), exports);
+tslib_1.__exportStar(require("./getHeadersObj.js"), exports);
+tslib_1.__exportStar(require("./with-cookies.js"), exports);

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

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFromModuleExportExpression = void 0;
+/* eslint-disable @typescript-eslint/return-await */
+const cross_helpers_1 = require("@graphql-mesh/cross-helpers");
+const defaultImportFn_js_1 = require("./defaultImportFn.js");
+async function loadFromModuleExportExpression(expression, options) {
+    if (typeof expression !== 'string') {
+        return Promise.resolve(expression);
+    }
+    const { defaultExportName, cwd, importFn = defaultImportFn_js_1.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;
+}
+exports.loadFromModuleExportExpression = loadFromModuleExportExpression;
+async function tryImport(modulePath, cwd, importFn) {
+    try {
+        return await importFn(modulePath);
+    }
+    catch (_a) {
+        if (!cross_helpers_1.path.isAbsolute(modulePath)) {
+            const absoluteModulePath = cross_helpers_1.path.isAbsolute(modulePath)
+                ? modulePath
+                : cross_helpers_1.path.join(cwd, modulePath);
+            return importFn(absoluteModulePath);
+        }
+    }
+}

package/cjs/logger.js

@@ -0,0 +1,127 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DefaultLogger = exports.titleBold = exports.debugColor = exports.errorColor = exports.infoColor = exports.warnColor = void 0;
+const cross_helpers_1 = require("@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',
+};
+const warnColor = msg => ANSI_CODES.orange + msg + ANSI_CODES.reset;
+exports.warnColor = warnColor;
+const infoColor = msg => ANSI_CODES.cyan + msg + ANSI_CODES.reset;
+exports.infoColor = infoColor;
+const errorColor = msg => ANSI_CODES.red + msg + ANSI_CODES.reset;
+exports.errorColor = errorColor;
+const debugColor = msg => ANSI_CODES.magenta + msg + ANSI_CODES.reset;
+exports.debugColor = debugColor;
+const titleBold = msg => ANSI_CODES.bold + msg + ANSI_CODES.reset;
+exports.titleBold = titleBold;
+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 cross_helpers_1.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 (cross_helpers_1.process.env.DEBUG === '1' ||
+            globalThis.DEBUG === '1' ||
+            this.name.includes(cross_helpers_1.process.env.DEBUG || globalThis.DEBUG));
+    }
+    get prefix() {
+        return this.name ? (0, exports.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} ${(0, exports.warnColor)(message)}`;
+        if (console.warn) {
+            console.warn(fullMessage);
+        }
+        else {
+            console.log(fullMessage);
+        }
+    }
+    info(...args) {
+        const message = this.getLoggerMessage({
+            args,
+        });
+        const fullMessage = `💡 ${this.prefix} ${(0, exports.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} ${(0, exports.errorColor)(message)}`;
+        console.log(fullMessage);
+    }
+    debug(...lazyArgs) {
+        if (this.isDebug) {
+            const message = this.handleLazyMessage({
+                lazyArgs,
+            });
+            const fullMessage = `🐛 ${this.prefix} ${(0, exports.debugColor)(message)}`;
+            if (console.debug) {
+                console.debug(fullMessage);
+            }
+            else {
+                console.log(fullMessage);
+            }
+        }
+    }
+    child(name) {
+        return new DefaultLogger(this.name ? `${this.name} - ${name}` : name);
+    }
+}
+exports.DefaultLogger = DefaultLogger;

package/cjs/package.json

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

package/cjs/parseAndPrintWithCache.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.gql = exports.printWithCache = exports.parseWithCache = void 0;
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const global_lru_cache_js_1 = require("./global-lru-cache.js");
+const parseCache = (0, global_lru_cache_js_1.createLruCache)(1000, 3600);
+const printCache = (0, global_lru_cache_js_1.createLruCache)(1000, 3600);
+function parseWithCache(sdl) {
+    const trimmedSdl = sdl.trim();
+    let document = parseCache.get(trimmedSdl);
+    if (!document) {
+        document = (0, graphql_1.parse)(trimmedSdl, { noLocation: true });
+        parseCache.set(trimmedSdl, document);
+        printCache.set(JSON.stringify(document), trimmedSdl);
+    }
+    return document;
+}
+exports.parseWithCache = parseWithCache;
+exports.printWithCache = (0, utils_1.memoize1)(function printWithCache(document) {
+    const stringifedDocumentJson = JSON.stringify(document);
+    let sdl = printCache.get(stringifedDocumentJson);
+    if (!sdl) {
+        sdl = (0, graphql_1.print)(document).trim();
+        printCache.set(stringifedDocumentJson, sdl);
+        parseCache.set(sdl, document);
+    }
+    return sdl;
+});
+function gql([sdl], ...args) {
+    let result = sdl;
+    for (const arg of args || []) {
+        if (typeof arg === 'string') {
+            result += arg;
+        }
+        else {
+            result += (0, exports.printWithCache)(arg);
+        }
+    }
+    return parseWithCache(result);
+}
+exports.gql = gql;

package/cjs/pubsub.js

@@ -0,0 +1,57 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.PubSub = void 0;
+const utils_1 = require("@graphql-tools/utils");
+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 (0, utils_1.observableToAsyncIterable)({
+            subscribe: observer => {
+                const subId = this.subscribe(triggerName, data => observer.next(data));
+                return {
+                    unsubscribe: () => this.unsubscribe(subId),
+                };
+            },
+        });
+    }
+}
+exports.PubSub = PubSub;