@graphql-tools/utils 8.7.0 → 8.8.0-alpha-6c480b2d.0

package/cjs/mergeDeep.js

@@ -0,0 +1,45 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.mergeDeep = void 0;
+const helpers_js_1 = require("./helpers.js");
+function mergeDeep(sources, respectPrototype = false) {
+    const target = sources[0] || {};
+    const output = {};
+    if (respectPrototype) {
+        Object.setPrototypeOf(output, Object.create(Object.getPrototypeOf(target)));
+    }
+    for (const source of sources) {
+        if (isObject(target) && isObject(source)) {
+            if (respectPrototype) {
+                const outputPrototype = Object.getPrototypeOf(output);
+                const sourcePrototype = Object.getPrototypeOf(source);
+                if (sourcePrototype) {
+                    for (const key of Object.getOwnPropertyNames(sourcePrototype)) {
+                        const descriptor = Object.getOwnPropertyDescriptor(sourcePrototype, key);
+                        if ((0, helpers_js_1.isSome)(descriptor)) {
+                            Object.defineProperty(outputPrototype, key, descriptor);
+                        }
+                    }
+                }
+            }
+            for (const key in source) {
+                if (isObject(source[key])) {
+                    if (!(key in output)) {
+                        Object.assign(output, { [key]: source[key] });
+                    }
+                    else {
+                        output[key] = mergeDeep([output[key], source[key]], respectPrototype);
+                    }
+                }
+                else {
+                    Object.assign(output, { [key]: source[key] });
+                }
+            }
+        }
+    }
+    return output;
+}
+exports.mergeDeep = mergeDeep;
+function isObject(item) {
+    return item && typeof item === 'object' && !Array.isArray(item);
+}

package/cjs/observableToAsyncIterable.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.observableToAsyncIterable = void 0;
+function observableToAsyncIterable(observable) {
+    const pullQueue = [];
+    const pushQueue = [];
+    let listening = true;
+    const pushValue = (value) => {
+        if (pullQueue.length !== 0) {
+            // It is safe to use the ! operator here as we check the length.
+            pullQueue.shift()({ value, done: false });
+        }
+        else {
+            pushQueue.push({ value, done: false });
+        }
+    };
+    const pushError = (error) => {
+        if (pullQueue.length !== 0) {
+            // It is safe to use the ! operator here as we check the length.
+            pullQueue.shift()({ value: { errors: [error] }, done: false });
+        }
+        else {
+            pushQueue.push({ value: { errors: [error] }, done: false });
+        }
+    };
+    const pushDone = () => {
+        if (pullQueue.length !== 0) {
+            // It is safe to use the ! operator here as we check the length.
+            pullQueue.shift()({ done: true });
+        }
+        else {
+            pushQueue.push({ done: true });
+        }
+    };
+    const pullValue = () => new Promise(resolve => {
+        if (pushQueue.length !== 0) {
+            const element = pushQueue.shift();
+            // either {value: {errors: [...]}} or {value: ...}
+            resolve(element);
+        }
+        else {
+            pullQueue.push(resolve);
+        }
+    });
+    const subscription = observable.subscribe({
+        next(value) {
+            pushValue(value);
+        },
+        error(err) {
+            pushError(err);
+        },
+        complete() {
+            pushDone();
+        },
+    });
+    const emptyQueue = () => {
+        if (listening) {
+            listening = false;
+            subscription.unsubscribe();
+            for (const resolve of pullQueue) {
+                resolve({ value: undefined, done: true });
+            }
+            pullQueue.length = 0;
+            pushQueue.length = 0;
+        }
+    };
+    return {
+        next() {
+            // return is a defined method, so it is safe to call it.
+            return listening ? pullValue() : this.return();
+        },
+        return() {
+            emptyQueue();
+            return Promise.resolve({ value: undefined, done: true });
+        },
+        throw(error) {
+            emptyQueue();
+            return Promise.reject(error);
+        },
+        [Symbol.asyncIterator]() {
+            return this;
+        },
+    };
+}
+exports.observableToAsyncIterable = observableToAsyncIterable;

package/cjs/package.json

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

package/cjs/parse-graphql-json.js

@@ -0,0 +1,44 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parseGraphQLJSON = void 0;
+const graphql_1 = require("graphql");
+function stripBOM(content) {
+    content = content.toString();
+    // Remove byte order marker. This catches EF BB BF (the UTF-8 BOM)
+    // because the buffer-to-string conversion in `fs.readFileSync()`
+    // translates it to FEFF, the UTF-16 BOM.
+    if (content.charCodeAt(0) === 0xfeff) {
+        content = content.slice(1);
+    }
+    return content;
+}
+function parseBOM(content) {
+    return JSON.parse(stripBOM(content));
+}
+function parseGraphQLJSON(location, jsonContent, options) {
+    let parsedJson = parseBOM(jsonContent);
+    if (parsedJson.data) {
+        parsedJson = parsedJson.data;
+    }
+    if (parsedJson.kind === 'Document') {
+        return {
+            location,
+            document: parsedJson,
+        };
+    }
+    else if (parsedJson.__schema) {
+        const schema = (0, graphql_1.buildClientSchema)(parsedJson, options);
+        return {
+            location,
+            schema,
+        };
+    }
+    else if (typeof parsedJson === 'string') {
+        return {
+            location,
+            rawSDL: parsedJson,
+        };
+    }
+    throw new Error(`Not valid JSON content`);
+}
+exports.parseGraphQLJSON = parseGraphQLJSON;

package/cjs/parse-graphql-sdl.js

@@ -0,0 +1,84 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isDescribable = exports.transformCommentsToDescriptions = exports.parseGraphQLSDL = void 0;
+const graphql_1 = require("graphql");
+const comments_js_1 = require("./comments.js");
+function parseGraphQLSDL(location, rawSDL, options = {}) {
+    let document;
+    try {
+        if (options.commentDescriptions && rawSDL.includes('#')) {
+            document = transformCommentsToDescriptions(rawSDL, options);
+            // If noLocation=true, we need to make sure to print and parse it again, to remove locations,
+            // since `transformCommentsToDescriptions` must have locations set in order to transform the comments
+            // into descriptions.
+            if (options.noLocation) {
+                document = (0, graphql_1.parse)((0, graphql_1.print)(document), options);
+            }
+        }
+        else {
+            document = (0, graphql_1.parse)(new graphql_1.Source(rawSDL, location), options);
+        }
+    }
+    catch (e) {
+        if (e.message.includes('EOF') && rawSDL.replace(/(\#[^*]*)/g, '').trim() === '') {
+            document = {
+                kind: graphql_1.Kind.DOCUMENT,
+                definitions: [],
+            };
+        }
+        else {
+            throw e;
+        }
+    }
+    return {
+        location,
+        document,
+    };
+}
+exports.parseGraphQLSDL = parseGraphQLSDL;
+function transformCommentsToDescriptions(sourceSdl, options = {}) {
+    const parsedDoc = (0, graphql_1.parse)(sourceSdl, {
+        ...options,
+        noLocation: false,
+    });
+    const modifiedDoc = (0, graphql_1.visit)(parsedDoc, {
+        leave: (node) => {
+            if (isDescribable(node)) {
+                const rawValue = (0, comments_js_1.getLeadingCommentBlock)(node);
+                if (rawValue !== undefined) {
+                    const commentsBlock = (0, comments_js_1.dedentBlockStringValue)('\n' + rawValue);
+                    const isBlock = commentsBlock.includes('\n');
+                    if (!node.description) {
+                        return {
+                            ...node,
+                            description: {
+                                kind: graphql_1.Kind.STRING,
+                                value: commentsBlock,
+                                block: isBlock,
+                            },
+                        };
+                    }
+                    else {
+                        return {
+                            ...node,
+                            description: {
+                                ...node.description,
+                                value: node.description.value + '\n' + commentsBlock,
+                                block: true,
+                            },
+                        };
+                    }
+                }
+            }
+        },
+    });
+    return modifiedDoc;
+}
+exports.transformCommentsToDescriptions = transformCommentsToDescriptions;
+function isDescribable(node) {
+    return ((0, graphql_1.isTypeSystemDefinitionNode)(node) ||
+        node.kind === graphql_1.Kind.FIELD_DEFINITION ||
+        node.kind === graphql_1.Kind.INPUT_VALUE_DEFINITION ||
+        node.kind === graphql_1.Kind.ENUM_VALUE_DEFINITION);
+}
+exports.isDescribable = isDescribable;