@graphql-tools/load 7.6.0 → 7.7.0-alpha-b76ec274.0

package/cjs/utils/helpers.js

@@ -0,0 +1,42 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useLimit = exports.useStack = exports.stringToHash = void 0;
+const tslib_1 = require("tslib");
+const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
+/**
+ * Converts a string to 32bit integer
+ */
+function stringToHash(str) {
+    let hash = 0;
+    if (str.length === 0) {
+        return hash;
+    }
+    let char;
+    for (let i = 0; i < str.length; i++) {
+        char = str.charCodeAt(i);
+        // tslint:disable-next-line: no-bitwise
+        hash = (hash << 5) - hash + char;
+        // tslint:disable-next-line: no-bitwise
+        hash = hash & hash;
+    }
+    return hash;
+}
+exports.stringToHash = stringToHash;
+function useStack(...fns) {
+    return (input) => {
+        function createNext(i) {
+            if (i >= fns.length) {
+                return () => { };
+            }
+            return function next() {
+                fns[i](input, createNext(i + 1));
+            };
+        }
+        fns[0](input, createNext(1));
+    };
+}
+exports.useStack = useStack;
+function useLimit(concurrency) {
+    return (0, p_limit_1.default)(concurrency);
+}
+exports.useLimit = useLimit;

package/cjs/utils/pointers.js

@@ -0,0 +1,31 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.normalizePointers = void 0;
+const utils_1 = require("@graphql-tools/utils");
+function normalizePointers(unnormalizedPointerOrPointers) {
+    const ignore = [];
+    const pointerOptionMap = {};
+    const handlePointer = (rawPointer, options = {}) => {
+        if (rawPointer.startsWith('!')) {
+            ignore.push(rawPointer.replace('!', ''));
+        }
+        else {
+            pointerOptionMap[rawPointer] = options;
+        }
+    };
+    for (const rawPointer of (0, utils_1.asArray)(unnormalizedPointerOrPointers)) {
+        if (typeof rawPointer === 'string') {
+            handlePointer(rawPointer);
+        }
+        else if (typeof rawPointer === 'object') {
+            for (const [path, options] of Object.entries(rawPointer)) {
+                handlePointer(path, options);
+            }
+        }
+        else {
+            throw new Error(`Invalid pointer '${rawPointer}'.`);
+        }
+    }
+    return { ignore, pointerOptionMap };
+}
+exports.normalizePointers = normalizePointers;

package/cjs/utils/queue.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.useSyncQueue = exports.useQueue = void 0;
+const tslib_1 = require("tslib");
+const p_limit_1 = tslib_1.__importDefault(require("p-limit"));
+function useQueue(options) {
+    const queue = [];
+    const limit = (options === null || options === void 0 ? void 0 : options.concurrency) ? (0, p_limit_1.default)(options.concurrency) : async (fn) => fn();
+    return {
+        add(fn) {
+            queue.push(() => limit(fn));
+        },
+        runAll() {
+            return Promise.all(queue.map(fn => fn()));
+        },
+    };
+}
+exports.useQueue = useQueue;
+function useSyncQueue() {
+    const queue = [];
+    return {
+        add(fn) {
+            queue.push(fn);
+        },
+        runAll() {
+            for (const fn of queue) {
+                fn();
+            }
+        },
+    };
+}
+exports.useSyncQueue = useSyncQueue;

package/esm/documents.js

@@ -0,0 +1,34 @@
+import { Kind } from 'graphql';
+import { loadTypedefs, loadTypedefsSync } from './load-typedefs.js';
+/**
+ * Kinds of AST nodes that are included in executable documents
+ */
+export const OPERATION_KINDS = [Kind.OPERATION_DEFINITION, Kind.FRAGMENT_DEFINITION];
+/**
+ * Kinds of AST nodes that are included in type system definition documents
+ */
+export const NON_OPERATION_KINDS = Object.keys(Kind)
+    .reduce((prev, v) => [...prev, Kind[v]], [])
+    .filter(v => !OPERATION_KINDS.includes(v));
+/**
+ * Asynchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
+export function loadDocuments(pointerOrPointers, options) {
+    return loadTypedefs(pointerOrPointers, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
+}
+/**
+ * Synchronously loads executable documents (i.e. operations and fragments) from
+ * the provided pointers. The pointers may be individual files or a glob pattern.
+ * The files themselves may be `.graphql` files or `.js` and `.ts` (in which
+ * case they will be parsed using graphql-tag-pluck).
+ * @param pointerOrPointers Pointers to the files to load the documents from
+ * @param options Additional options
+ */
+export function loadDocumentsSync(pointerOrPointers, options) {
+    return loadTypedefsSync(pointerOrPointers, { noRequire: true, filterKinds: NON_OPERATION_KINDS, ...options });
+}

package/esm/filter-document-kind.js

@@ -0,0 +1,31 @@
+import { Kind } from 'graphql';
+import { env } from 'process';
+/**
+ * @internal
+ */
+export const filterKind = (content, filterKinds) => {
+    if (content && content.definitions && content.definitions.length && filterKinds && filterKinds.length > 0) {
+        const invalidDefinitions = [];
+        const validDefinitions = [];
+        for (const definitionNode of content.definitions) {
+            if (filterKinds.includes(definitionNode.kind)) {
+                invalidDefinitions.push(definitionNode);
+            }
+            else {
+                validDefinitions.push(definitionNode);
+            }
+        }
+        if (invalidDefinitions.length > 0) {
+            if (env['DEBUG']) {
+                for (const d of invalidDefinitions) {
+                    console.log(`Filtered document of kind ${d.kind} due to filter policy (${filterKinds.join(', ')})`);
+                }
+            }
+        }
+        return {
+            kind: Kind.DOCUMENT,
+            definitions: validDefinitions,
+        };
+    }
+    return content;
+};

package/esm/index.js

@@ -0,0 +1,4 @@
+export * from './load-typedefs.js';
+export * from './schema.js';
+export * from './documents.js';
+export * from './filter-document-kind.js';

package/esm/load-typedefs/collect-sources.js

@@ -0,0 +1,167 @@
+import { isDocumentString, parseGraphQLSDL, getDocumentNodeFromSchema, asArray } from '@graphql-tools/utils';
+import { isSchema, Kind } from 'graphql';
+import { loadFile, loadFileSync } from './load-file.js';
+import { stringToHash, useStack } from '../utils/helpers.js';
+import { useCustomLoader, useCustomLoaderSync } from '../utils/custom-loader.js';
+import { useQueue, useSyncQueue } from '../utils/queue.js';
+import { createRequire } from 'module';
+import { cwd } from 'process';
+const CONCURRENCY_LIMIT = 50;
+export async function collectSources({ pointerOptionMap, options, }) {
+    const sources = [];
+    const queue = useQueue({ concurrency: CONCURRENCY_LIMIT });
+    const { addSource, collect } = createHelpers({
+        sources,
+        stack: [collectDocumentString, collectCustomLoader, collectFallback],
+    });
+    for (const pointer in pointerOptionMap) {
+        const pointerOptions = pointerOptionMap[pointer];
+        collect({
+            pointer,
+            pointerOptions,
+            pointerOptionMap,
+            options,
+            addSource,
+            queue: queue.add,
+        });
+    }
+    await queue.runAll();
+    return sources;
+}
+export function collectSourcesSync({ pointerOptionMap, options, }) {
+    const sources = [];
+    const queue = useSyncQueue();
+    const { addSource, collect } = createHelpers({
+        sources,
+        stack: [collectDocumentString, collectCustomLoaderSync, collectFallbackSync],
+    });
+    for (const pointer in pointerOptionMap) {
+        const pointerOptions = pointerOptionMap[pointer];
+        collect({
+            pointer,
+            pointerOptions,
+            pointerOptionMap,
+            options,
+            addSource,
+            queue: queue.add,
+        });
+    }
+    queue.runAll();
+    return sources;
+}
+function createHelpers({ sources, stack }) {
+    const addSource = ({ source }) => {
+        sources.push(source);
+    };
+    const collect = useStack(...stack);
+    return {
+        addSource,
+        collect,
+    };
+}
+function addResultOfCustomLoader({ pointer, result, addSource, }) {
+    if (isSchema(result)) {
+        addSource({
+            source: {
+                location: pointer,
+                schema: result,
+                document: getDocumentNodeFromSchema(result),
+            },
+            pointer,
+            noCache: true,
+        });
+    }
+    else if (result.kind && result.kind === Kind.DOCUMENT) {
+        addSource({
+            source: {
+                document: result,
+                location: pointer,
+            },
+            pointer,
+        });
+    }
+    else if (result.document) {
+        addSource({
+            source: {
+                location: pointer,
+                ...result,
+            },
+            pointer,
+        });
+    }
+}
+function collectDocumentString({ pointer, pointerOptions, options, addSource, queue }, next) {
+    if (isDocumentString(pointer)) {
+        return queue(() => {
+            const source = parseGraphQLSDL(`${stringToHash(pointer)}.graphql`, pointer, {
+                ...options,
+                ...pointerOptions,
+            });
+            addSource({
+                source,
+                pointer,
+            });
+        });
+    }
+    next();
+}
+function collectCustomLoader({ pointer, pointerOptions, queue, addSource, options, pointerOptionMap }, next) {
+    if (pointerOptions.loader) {
+        return queue(async () => {
+            await Promise.all(asArray(pointerOptions.require).map(m => import(m)));
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore TODO options.cwd is possibly undefined, but it seems like no test covers this path
+            const loader = await useCustomLoader(pointerOptions.loader, options.cwd);
+            const result = await loader(pointer, { ...options, ...pointerOptions }, pointerOptionMap);
+            if (!result) {
+                return;
+            }
+            addResultOfCustomLoader({ pointer, result, addSource });
+        });
+    }
+    next();
+}
+function collectCustomLoaderSync({ pointer, pointerOptions, queue, addSource, options, pointerOptionMap }, next) {
+    if (pointerOptions.loader) {
+        return queue(() => {
+            const cwdRequire = createRequire(options.cwd || cwd());
+            for (const m of asArray(pointerOptions.require)) {
+                cwdRequire(m);
+            }
+            // eslint-disable-next-line @typescript-eslint/ban-ts-comment
+            // @ts-ignore TODO options.cwd is possibly undefined, but it seems like no test covers this path
+            const loader = useCustomLoaderSync(pointerOptions.loader, options.cwd);
+            const result = loader(pointer, { ...options, ...pointerOptions }, pointerOptionMap);
+            if (result) {
+                addResultOfCustomLoader({ pointer, result, addSource });
+            }
+        });
+    }
+    next();
+}
+function collectFallback({ queue, pointer, options, pointerOptions, addSource }) {
+    return queue(async () => {
+        const sources = await loadFile(pointer, {
+            ...options,
+            ...pointerOptions,
+        });
+        if (sources) {
+            for (const source of sources) {
+                addSource({ source, pointer });
+            }
+        }
+    });
+}
+function collectFallbackSync({ queue, pointer, options, pointerOptions, addSource }) {
+    return queue(() => {
+        const sources = loadFileSync(pointer, {
+            ...options,
+            ...pointerOptions,
+        });
+        if (sources) {
+            for (const source of sources) {
+                addSource({ source, pointer });
+            }
+        }
+    });
+}

package/esm/load-typedefs/load-file.js

@@ -0,0 +1,81 @@
+import { AggregateError } from '@graphql-tools/utils';
+import { env } from 'process';
+export async function loadFile(pointer, options) {
+    var _a;
+    let results = (_a = options.cache) === null || _a === void 0 ? void 0 : _a[pointer];
+    if (!results) {
+        results = [];
+        const errors = [];
+        await Promise.all(options.loaders.map(async (loader) => {
+            try {
+                const loaderResults = await loader.load(pointer, options);
+                loaderResults === null || loaderResults === void 0 ? void 0 : loaderResults.forEach(result => results.push(result));
+            }
+            catch (error) {
+                if (env['DEBUG']) {
+                    console.error(error);
+                }
+                if (error instanceof AggregateError) {
+                    for (const errorElement of error.errors) {
+                        errors.push(errorElement);
+                    }
+                }
+                else {
+                    errors.push(error);
+                }
+            }
+        }));
+        if (results.length === 0 && errors.length > 0) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new AggregateError(errors, `Failed to find any GraphQL type definitions in: ${pointer};\n - ${errors
+                .map(error => error.message)
+                .join('\n  - ')}`);
+        }
+        if (options.cache) {
+            options.cache[pointer] = results;
+        }
+    }
+    return results;
+}
+export function loadFileSync(pointer, options) {
+    var _a;
+    let results = (_a = options.cache) === null || _a === void 0 ? void 0 : _a[pointer];
+    if (!results) {
+        results = [];
+        const errors = [];
+        for (const loader of options.loaders) {
+            try {
+                // We check for the existence so it is okay to force non null
+                const loaderResults = loader.loadSync(pointer, options);
+                loaderResults === null || loaderResults === void 0 ? void 0 : loaderResults.forEach(result => results.push(result));
+            }
+            catch (error) {
+                if (env['DEBUG']) {
+                    console.error(error);
+                }
+                if (error instanceof AggregateError) {
+                    for (const errorElement of error.errors) {
+                        errors.push(errorElement);
+                    }
+                }
+                else {
+                    errors.push(error);
+                }
+            }
+        }
+        if (results.length === 0 && errors.length > 0) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new AggregateError(errors, `Failed to find any GraphQL type definitions in: ${pointer};\n - ${errors
+                .map(error => error.message)
+                .join('\n  - ')}`);
+        }
+        if (options.cache) {
+            options.cache[pointer] = results;
+        }
+    }
+    return results;
+}

package/esm/load-typedefs/options.js

@@ -0,0 +1,6 @@
+import { cwd } from 'process';
+export function applyDefaultOptions(options) {
+    options.cache = options.cache || {};
+    options.cwd = options.cwd || cwd();
+    options.sort = 'sort' in options ? options.sort : true;
+}

package/esm/load-typedefs/parse.js

@@ -0,0 +1,58 @@
+import { printSchemaWithDirectives, parseGraphQLSDL, printWithComments, resetComments, } from '@graphql-tools/utils';
+import { filterKind } from '../filter-document-kind.js';
+export function parseSource({ partialSource, options, pointerOptionMap, addValidSource }) {
+    if (partialSource) {
+        const input = prepareInput({
+            source: partialSource,
+            options,
+            pointerOptionMap,
+        });
+        parseSchema(input);
+        parseRawSDL(input);
+        if (input.source.document) {
+            useKindsFilter(input);
+            useComments(input);
+            collectValidSources(input, addValidSource);
+        }
+    }
+}
+//
+function prepareInput({ source, options, pointerOptionMap, }) {
+    let specificOptions = {
+        ...options,
+    };
+    if (source.location) {
+        specificOptions = {
+            ...specificOptions,
+            ...pointerOptionMap[source.location],
+        };
+    }
+    return { source: { ...source }, options: specificOptions };
+}
+function parseSchema(input) {
+    if (input.source.schema) {
+        input.source.rawSDL = printSchemaWithDirectives(input.source.schema, input.options);
+    }
+}
+function parseRawSDL(input) {
+    if (input.source.rawSDL) {
+        input.source.document = parseGraphQLSDL(input.source.location, input.source.rawSDL, input.options).document;
+    }
+}
+function useKindsFilter(input) {
+    if (input.options.filterKinds) {
+        input.source.document = filterKind(input.source.document, input.options.filterKinds);
+    }
+}
+function useComments(input) {
+    if (!input.source.rawSDL && input.source.document) {
+        input.source.rawSDL = printWithComments(input.source.document);
+        resetComments();
+    }
+}
+function collectValidSources(input, addValidSource) {
+    var _a;
+    if (((_a = input.source.document) === null || _a === void 0 ? void 0 : _a.definitions) && input.source.document.definitions.length > 0) {
+        addValidSource(input.source);
+    }
+}

package/esm/load-typedefs.js

@@ -0,0 +1,79 @@
+import { compareStrings, asArray } from '@graphql-tools/utils';
+import { normalizePointers } from './utils/pointers.js';
+import { applyDefaultOptions } from './load-typedefs/options.js';
+import { collectSources, collectSourcesSync } from './load-typedefs/collect-sources.js';
+import { parseSource } from './load-typedefs/parse.js';
+import { useLimit } from './utils/helpers.js';
+const CONCURRENCY_LIMIT = 100;
+/**
+ * Asynchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * loadTypedefs does not merge the typeDefs when `#import` is used ( https://github.com/ardatan/graphql-tools/issues/2980#issuecomment-1003692728 )
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
+export async function loadTypedefs(pointerOrPointers, options) {
+    const { ignore, pointerOptionMap } = normalizePointers(pointerOrPointers);
+    options.ignore = asArray(options.ignore || []);
+    options.ignore.push(...ignore);
+    applyDefaultOptions(options);
+    const sources = await collectSources({
+        pointerOptionMap,
+        options,
+    });
+    const validSources = [];
+    // If we have few k of files it may be an issue
+    const limit = useLimit(CONCURRENCY_LIMIT);
+    await Promise.all(sources.map(partialSource => limit(() => parseSource({
+        partialSource,
+        options,
+        pointerOptionMap,
+        addValidSource(source) {
+            validSources.push(source);
+        },
+    }))));
+    return prepareResult({ options, pointerOptionMap, validSources });
+}
+/**
+ * Synchronously loads any GraphQL documents (i.e. executable documents like
+ * operations and fragments as well as type system definitions) from the
+ * provided pointers.
+ * @param pointerOrPointers Pointers to the sources to load the documents from
+ * @param options Additional options
+ */
+export function loadTypedefsSync(pointerOrPointers, options) {
+    const { ignore, pointerOptionMap } = normalizePointers(pointerOrPointers);
+    options.ignore = asArray(options.ignore || []).concat(ignore);
+    applyDefaultOptions(options);
+    const sources = collectSourcesSync({
+        pointerOptionMap,
+        options,
+    });
+    const validSources = [];
+    for (const partialSource of sources) {
+        parseSource({
+            partialSource,
+            options,
+            pointerOptionMap,
+            addValidSource(source) {
+                validSources.push(source);
+            },
+        });
+    }
+    return prepareResult({ options, pointerOptionMap, validSources });
+}
+//
+function prepareResult({ options, pointerOptionMap, validSources, }) {
+    const pointerList = Object.keys(pointerOptionMap);
+    if (pointerList.length > 0 && validSources.length === 0) {
+        throw new Error(`
+      Unable to find any GraphQL type definitions for the following pointers:
+        ${pointerList.map(p => `
+          - ${p}
+          `)}`);
+    }
+    return options.sort
+        ? validSources.sort((left, right) => compareStrings(left.location, right.location))
+        : validSources;
+}

package/esm/schema.js

@@ -0,0 +1,81 @@
+import { loadTypedefs, loadTypedefsSync } from './load-typedefs.js';
+import { Source as GraphQLSource, print, lexicographicSortSchema, } from 'graphql';
+import { OPERATION_KINDS } from './documents.js';
+import { mergeSchemas } from '@graphql-tools/schema';
+/**
+ * Asynchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
+export async function loadSchema(schemaPointers, options) {
+    var _a, _b;
+    const sources = await loadTypedefs(schemaPointers, {
+        ...options,
+        filterKinds: OPERATION_KINDS,
+    });
+    const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
+    schemas.push(...((_a = options.schemas) !== null && _a !== void 0 ? _a : []));
+    const mergeSchemasOptions = {
+        ...options,
+        schemas: schemas.concat((_b = options.schemas) !== null && _b !== void 0 ? _b : []),
+        typeDefs,
+    };
+    const schema = (typeDefs === null || typeDefs === void 0 ? void 0 : typeDefs.length) === 0 && (schemas === null || schemas === void 0 ? void 0 : schemas.length) === 1 ? schemas[0] : mergeSchemas(mergeSchemasOptions);
+    if (options === null || options === void 0 ? void 0 : options.includeSources) {
+        includeSources(schema, sources);
+    }
+    return options.sort ? lexicographicSortSchema(schema) : schema;
+}
+/**
+ * Synchronously loads a schema from the provided pointers.
+ * @param schemaPointers Pointers to the sources to load the schema from
+ * @param options Additional options
+ */
+export function loadSchemaSync(schemaPointers, options) {
+    const sources = loadTypedefsSync(schemaPointers, {
+        filterKinds: OPERATION_KINDS,
+        ...options,
+    });
+    const { schemas, typeDefs } = collectSchemasAndTypeDefs(sources);
+    const schema = mergeSchemas({
+        schemas,
+        typeDefs,
+        ...options,
+    });
+    if (options === null || options === void 0 ? void 0 : options.includeSources) {
+        includeSources(schema, sources);
+    }
+    return options.sort ? lexicographicSortSchema(schema) : schema;
+}
+function includeSources(schema, sources) {
+    const finalSources = [];
+    for (const source of sources) {
+        if (source.rawSDL) {
+            finalSources.push(new GraphQLSource(source.rawSDL, source.location));
+        }
+        else if (source.document) {
+            finalSources.push(new GraphQLSource(print(source.document), source.location));
+        }
+    }
+    schema.extensions = {
+        ...schema.extensions,
+        sources: finalSources,
+        extendedSources: sources,
+    };
+}
+function collectSchemasAndTypeDefs(sources) {
+    const schemas = [];
+    const typeDefs = [];
+    for (const source of sources) {
+        if (source.schema) {
+            schemas.push(source.schema);
+        }
+        else if (source.document) {
+            typeDefs.push(source.document);
+        }
+    }
+    return {
+        schemas,
+        typeDefs,
+    };
+}