@graphql-toolkit/file-loading/index.esm.js

const DEFAULT_IGNORED_EXTENSIONS = ['spec', 'test', 'd', 'map'];
const DEFAULT_EXTENSIONS = ['gql', 'graphql', 'graphqls', 'ts', 'js'];
const DEFAULT_EXPORT_NAMES = ['typeDefs', 'schema'];
function asArray(obj) {
    if (obj instanceof Array) {
        return obj;
    }
    else {
        return [obj];
    }
}
function isDirectory(path) {
    const { existsSync, statSync } = require('fs');
    return existsSync(path) && statSync(path).isDirectory();
}
function scanForFiles(globStr, globOptions = {}) {
    const globby = require('globby');
    return globby.sync(globStr, { absolute: true, ...globOptions });
}
function buildGlob(basePath, extensions, ignoredExtensions = [], recursive) {
    return `${basePath}${recursive ? '/**' : ''}/${ignoredExtensions.length > 0 ? `!(${ignoredExtensions.map(e => '*.' + e).join('|')})` : '*'}+(${extensions.map(e => '*.' + e).join('|')})`;
}
function extractExports(fileExport, exportNames) {
    if (!fileExport) {
        return null;
    }
    if (fileExport.default) {
        for (const exportName of exportNames) {
            if (fileExport.default[exportName]) {
                return fileExport.default[exportName];
            }
        }
        return fileExport.default;
    }
    for (const exportName of exportNames) {
        if (fileExport[exportName]) {
            return fileExport[exportName];
        }
    }
    return fileExport;
}
const LoadFilesDefaultOptions = {
    ignoredExtensions: DEFAULT_IGNORED_EXTENSIONS,
    extensions: DEFAULT_EXTENSIONS,
    useRequire: false,
    requireMethod: null,
    globOptions: {
        absolute: true,
    },
    exportNames: DEFAULT_EXPORT_NAMES,
    recursive: true,
    ignoreIndex: false,
};
function loadFiles(pattern, options = LoadFilesDefaultOptions) {
    const execOptions = { ...LoadFilesDefaultOptions, ...options };
    const unixify = require('unixify');
    const relevantPaths = scanForFiles(asArray(pattern).map(path => (isDirectory(path) ? buildGlob(unixify(path), execOptions.extensions, execOptions.ignoredExtensions, execOptions.recursive) : unixify(path))), options.globOptions);
    return relevantPaths
        .map(path => {
        if (!checkExtension(path, options)) {
            return;
        }
        if (isIndex(path, execOptions.extensions) && options.ignoreIndex) {
            return false;
        }
        const { extname } = require('path');
        const extension = extname(path);
        if (extension.endsWith('.js') || extension.endsWith('.ts') || execOptions.useRequire) {
            const fileExports = (execOptions.requireMethod ? execOptions.requireMethod : require)(path);
            const extractedExport = extractExports(fileExports, execOptions.exportNames);
            if (extractedExport.typeDefs && extractedExport.resolvers) {
                return extractedExport;
            }
            if (extractedExport.schema) {
                return extractedExport.schema;
            }
            if (extractedExport.typeDef) {
                return extractedExport.typeDef;
            }
            if (extractedExport.typeDefs) {
                return extractedExport.typeDefs;
            }
            if (extractedExport.resolver) {
                return extractedExport.resolver;
            }
            if (extractedExport.resolvers) {
                return extractedExport.resolvers;
            }
            return extractedExport;
        }
        else {
            const { readFileSync } = require('fs');
            return readFileSync(path, { encoding: 'utf-8' });
        }
    })
        .filter(v => v);
}
async function scanForFilesAsync(globStr, globOptions = {}) {
    const { default: globby } = await import('globby');
    return globby(globStr, { absolute: true, ...globOptions });
}
const checkExtension = (path, { extensions, ignoredExtensions }) => {
    if (ignoredExtensions) {
        for (const ignoredExtension of ignoredExtensions) {
            if (path.endsWith(ignoredExtension)) {
                return false;
            }
        }
    }
    if (extensions) {
        for (const extension of extensions) {
            if (path.endsWith(extension)) {
                return true;
            }
        }
    }
    else {
        return true;
    }
    return false;
};
async function loadFilesAsync(pattern, options = LoadFilesDefaultOptions) {
    const execOptions = { ...LoadFilesDefaultOptions, ...options };
    const unixify = await import('unixify').then(m => m.default || m);
    const relevantPaths = await scanForFilesAsync(asArray(pattern).map(path => (isDirectory(path) ? buildGlob(unixify(path), execOptions.extensions, execOptions.ignoredExtensions, execOptions.recursive) : unixify(path))), options.globOptions);
    const require$ = (path) => import(path);
    return Promise.all(relevantPaths
        .map(async (path) => {
        if (!checkExtension(path, options)) {
            return;
        }
        if (isIndex(path, execOptions.extensions) && options.ignoreIndex) {
            return false;
        }
        const { extname } = await import('path');
        const extension = extname(path);
        if (extension.endsWith('.js') || extension.endsWith('.ts') || execOptions.useRequire) {
            const fileExports = await (execOptions.requireMethod ? execOptions.requireMethod : require$)(path);
            const extractedExport = extractExports(fileExports, execOptions.exportNames);
            if (extractedExport.resolver) {
                return extractedExport.resolver;
            }
            if (extractedExport.resolvers) {
                return extractedExport.resolvers;
            }
            return extractedExport;
        }
        else {
            return new Promise(async (resolve, reject) => {
                const { readFile } = await import('fs');
                readFile(path, { encoding: 'utf-8' }, (err, data) => {
                    if (err) {
                        reject(err);
                    }
                    resolve(data);
                });
            });
        }
    })
        .filter(p => p));
}
function isIndex(path, extensions = []) {
    const IS_INDEX = /(\/|\\)index\.[^\/\\]+$/i; // (/ or \) AND `index.` AND (everything except \ and /)(end of line)
    return IS_INDEX.test(path) && extensions.some(ext => path.endsWith('.' + ext));
}

export { loadFiles, loadFilesAsync, loadFiles as loadResolversFiles, loadFilesAsync as loadResolversFilesAsync, loadFiles as loadSchemaFiles, loadFilesAsync as loadSchemaFilesAsync };