@graphql-tools/code-file-loader 7.2.19 → 7.3.0-alpha-6c480b2d.0

package/cjs/exports.js

@@ -0,0 +1,69 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pickExportFromModuleSync = exports.pickExportFromModule = void 0;
+const graphql_1 = require("graphql");
+const helpers_js_1 = require("./helpers.js");
+const identifiersToLookFor = ['default', 'schema', 'typeDefs', 'data'];
+// Pick exports
+/**
+ * @internal
+ */
+function pickExportFromModule({ module, filepath }) {
+    ensureModule({ module, filepath });
+    return resolveModule(ensureExports({ module, filepath }));
+}
+exports.pickExportFromModule = pickExportFromModule;
+/**
+ * @internal
+ */
+function pickExportFromModuleSync({ module, filepath }) {
+    ensureModule({ module, filepath });
+    return resolveModuleSync(ensureExports({ module, filepath }));
+}
+exports.pickExportFromModuleSync = pickExportFromModuleSync;
+// module
+async function resolveModule(identifiers) {
+    const exportValue = await (0, helpers_js_1.pick)(await identifiers, identifiersToLookFor);
+    return resolveExport(exportValue);
+}
+function resolveModuleSync(identifiers) {
+    const exportValue = (0, helpers_js_1.pick)(identifiers, identifiersToLookFor);
+    return resolveExport(exportValue);
+}
+// validate
+function ensureModule({ module, filepath }) {
+    if (!module) {
+        throw new Error(`Invalid export from export file ${filepath}: empty export!`);
+    }
+}
+function ensureExports({ module, filepath }) {
+    const identifiers = (0, helpers_js_1.pick)(module, identifiersToLookFor);
+    if (!identifiers) {
+        throw new Error(`Invalid export from export file ${filepath}: missing default export or 'schema' export!`);
+    }
+    return identifiers;
+}
+// Decide what to do with an exported value
+function resolveExport(fileExport) {
+    try {
+        if ((0, graphql_1.isSchema)(fileExport)) {
+            return fileExport;
+        }
+        if ((0, helpers_js_1.isSchemaText)(fileExport)) {
+            return (0, graphql_1.parse)(fileExport);
+        }
+        if ((0, helpers_js_1.isWrappedSchemaJson)(fileExport)) {
+            return (0, graphql_1.buildClientSchema)(fileExport.data);
+        }
+        if ((0, helpers_js_1.isSchemaJson)(fileExport)) {
+            return (0, graphql_1.buildClientSchema)(fileExport);
+        }
+        if ((0, helpers_js_1.isSchemaAst)(fileExport)) {
+            return fileExport;
+        }
+        return null;
+    }
+    catch (e) {
+        throw new Error('Exported schema must be of type GraphQLSchema, text, AST, or introspection JSON.');
+    }
+}

package/cjs/helpers.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.isSchemaAst = exports.isSchemaJson = exports.isWrappedSchemaJson = exports.isSchemaText = exports.pick = void 0;
+/**
+ * @internal
+ */
+function pick(obj, keys) {
+    for (const key of keys) {
+        if (obj[key]) {
+            return obj[key];
+        }
+    }
+    return obj;
+}
+exports.pick = pick;
+// checkers
+/**
+ * @internal
+ */
+function isSchemaText(obj) {
+    return typeof obj === 'string';
+}
+exports.isSchemaText = isSchemaText;
+/**
+ * @internal
+ */
+function isWrappedSchemaJson(obj) {
+    const json = obj;
+    return json.data !== undefined && json.data.__schema !== undefined;
+}
+exports.isWrappedSchemaJson = isWrappedSchemaJson;
+/**
+ * @internal
+ */
+function isSchemaJson(obj) {
+    const json = obj;
+    return json !== undefined && json.__schema !== undefined;
+}
+exports.isSchemaJson = isSchemaJson;
+/**
+ * @internal
+ */
+function isSchemaAst(obj) {
+    return obj.kind !== undefined;
+}
+exports.isSchemaAst = isSchemaAst;

package/cjs/index.js

@@ -0,0 +1,256 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.CodeFileLoader = void 0;
+const tslib_1 = require("tslib");
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const graphql_tag_pluck_1 = require("@graphql-tools/graphql-tag-pluck");
+const globby_1 = tslib_1.__importDefault(require("globby"));
+const unixify_1 = tslib_1.__importDefault(require("unixify"));
+const load_from_module_js_1 = require("./load-from-module.js");
+const path_1 = require("path");
+const process_1 = require("process");
+const fs_1 = require("fs");
+const module_1 = require("module");
+const { readFile, access } = fs_1.promises;
+const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.svelte'];
+function createGlobbyOptions(options) {
+    return { absolute: true, ...options, ignore: [] };
+}
+const buildIgnoreGlob = (path) => `!${path}`;
+/**
+ * This loader loads GraphQL documents and type definitions from code files
+ * using `graphql-tag-pluck`.
+ *
+ * ```js
+ * const documents = await loadDocuments('queries/*.js', {
+ *   loaders: [
+ *     new CodeFileLoader()
+ *   ]
+ * });
+ * ```
+ *
+ * Supported extensions include: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`
+ */
+class CodeFileLoader {
+    constructor(config) {
+        this.config = config !== null && config !== void 0 ? config : {};
+    }
+    getMergedOptions(options) {
+        return { ...this.config, ...options };
+    }
+    async canLoad(pointer, options) {
+        options = this.getMergedOptions(options);
+        if ((0, utils_1.isValidPath)(pointer)) {
+            if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
+                const normalizedFilePath = (0, path_1.isAbsolute)(pointer) ? pointer : (0, path_1.resolve)(options.cwd || (0, process_1.cwd)(), pointer);
+                try {
+                    await access(normalizedFilePath);
+                    return true;
+                }
+                catch (_a) {
+                    return false;
+                }
+            }
+        }
+        return false;
+    }
+    canLoadSync(pointer, options) {
+        options = this.getMergedOptions(options);
+        if ((0, utils_1.isValidPath)(pointer)) {
+            if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
+                const normalizedFilePath = (0, path_1.isAbsolute)(pointer) ? pointer : (0, path_1.resolve)(options.cwd || (0, process_1.cwd)(), pointer);
+                return (0, fs_1.existsSync)(normalizedFilePath);
+            }
+        }
+        return false;
+    }
+    _buildGlobs(glob, options) {
+        const ignores = (0, utils_1.asArray)(options.ignore || []);
+        const globs = [(0, unixify_1.default)(glob), ...ignores.map(v => buildIgnoreGlob((0, unixify_1.default)(v)))];
+        return globs;
+    }
+    async resolveGlobs(glob, options) {
+        options = this.getMergedOptions(options);
+        const globs = this._buildGlobs(glob, options);
+        return (0, globby_1.default)(globs, createGlobbyOptions(options));
+    }
+    resolveGlobsSync(glob, options) {
+        options = this.getMergedOptions(options);
+        const globs = this._buildGlobs(glob, options);
+        return globby_1.default.sync(globs, createGlobbyOptions(options));
+    }
+    async load(pointer, options) {
+        options = this.getMergedOptions(options);
+        const resolvedPaths = await this.resolveGlobs(pointer, options);
+        const finalResult = [];
+        const errors = [];
+        await Promise.all(resolvedPaths.map(async (path) => {
+            try {
+                const result = await this.handleSinglePath(path, options);
+                result === null || result === void 0 ? void 0 : result.forEach(result => finalResult.push(result));
+            }
+            catch (e) {
+                if (process_1.env['DEBUG']) {
+                    console.error(e);
+                }
+                errors.push(e);
+            }
+        }));
+        if (errors.length > 0 && (options.noSilentErrors || finalResult.length === 0)) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new utils_1.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
+        }
+        return finalResult;
+    }
+    loadSync(pointer, options) {
+        options = this.getMergedOptions(options);
+        const resolvedPaths = this.resolveGlobsSync(pointer, options);
+        const finalResult = [];
+        const errors = [];
+        for (const path of resolvedPaths) {
+            if (this.canLoadSync(path, options)) {
+                try {
+                    const result = this.handleSinglePathSync(path, options);
+                    result === null || result === void 0 ? void 0 : result.forEach(result => finalResult.push(result));
+                }
+                catch (e) {
+                    if (process_1.env['DEBUG']) {
+                        console.error(e);
+                    }
+                    errors.push(e);
+                }
+            }
+        }
+        if (errors.length > 0 && (options.noSilentErrors || finalResult.length === 0)) {
+            if (errors.length === 1) {
+                throw errors[0];
+            }
+            throw new utils_1.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
+        }
+        return finalResult;
+    }
+    async handleSinglePath(location, options) {
+        if (!(await this.canLoad(location, options))) {
+            return [];
+        }
+        options = this.getMergedOptions(options);
+        const normalizedFilePath = ensureAbsolutePath(location, options);
+        const errors = [];
+        if (!options.noPluck) {
+            try {
+                const content = await readFile(normalizedFilePath, { encoding: 'utf-8' });
+                const sources = await (0, graphql_tag_pluck_1.gqlPluckFromCodeString)(normalizedFilePath, content, options.pluckConfig);
+                if (sources.length) {
+                    return sources.map(source => ({
+                        rawSDL: source.body,
+                        document: (0, graphql_1.parse)(source),
+                        location,
+                    }));
+                }
+            }
+            catch (e) {
+                if (process_1.env['DEBUG']) {
+                    console.error(`Failed to load schema from code file "${normalizedFilePath}": ${e.message}`);
+                }
+                errors.push(e);
+            }
+        }
+        if (!options.noRequire) {
+            try {
+                if (options && options.require) {
+                    await Promise.all((0, utils_1.asArray)(options.require).map(m => Promise.resolve().then(() => tslib_1.__importStar(require(m)))));
+                }
+                const loaded = await (0, load_from_module_js_1.tryToLoadFromExport)(normalizedFilePath);
+                const sources = (0, utils_1.asArray)(loaded)
+                    .map(value => resolveSource(location, value, options))
+                    .filter(Boolean);
+                if (sources.length) {
+                    return sources;
+                }
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+        return [];
+    }
+    handleSinglePathSync(location, options) {
+        if (!this.canLoadSync(location, options)) {
+            return [];
+        }
+        options = this.getMergedOptions(options);
+        const normalizedFilePath = ensureAbsolutePath(location, options);
+        const errors = [];
+        if (!options.noPluck) {
+            try {
+                const content = (0, fs_1.readFileSync)(normalizedFilePath, { encoding: 'utf-8' });
+                const sources = (0, graphql_tag_pluck_1.gqlPluckFromCodeStringSync)(normalizedFilePath, content, options.pluckConfig);
+                if (sources.length) {
+                    return sources.map(source => ({
+                        rawSDL: source.body,
+                        document: (0, graphql_1.parse)(source),
+                        location,
+                    }));
+                }
+            }
+            catch (e) {
+                if (process_1.env['DEBUG']) {
+                    console.error(`Failed to load schema from code file "${normalizedFilePath}": ${e.message}`);
+                }
+                errors.push(e);
+            }
+        }
+        if (!options.noRequire) {
+            try {
+                if (options && options.require) {
+                    const cwdRequire = (0, module_1.createRequire)(options.cwd || (0, process_1.cwd)());
+                    for (const m of (0, utils_1.asArray)(options.require)) {
+                        cwdRequire(m);
+                    }
+                }
+                const loaded = (0, load_from_module_js_1.tryToLoadFromExportSync)(normalizedFilePath);
+                const sources = (0, utils_1.asArray)(loaded)
+                    .map(value => resolveSource(location, value, options))
+                    .filter(Boolean);
+                if (sources.length) {
+                    return sources;
+                }
+            }
+            catch (e) {
+                errors.push(e);
+            }
+        }
+        if (errors.length > 0) {
+            throw errors[0];
+        }
+        return null;
+    }
+}
+exports.CodeFileLoader = CodeFileLoader;
+function resolveSource(pointer, value, options) {
+    if (typeof value === 'string') {
+        return (0, utils_1.parseGraphQLSDL)(pointer, value, options);
+    }
+    else if ((0, graphql_1.isSchema)(value)) {
+        return {
+            location: pointer,
+            schema: value,
+        };
+    }
+    else if ((0, utils_1.isDocumentNode)(value)) {
+        return {
+            location: pointer,
+            document: value,
+        };
+    }
+    return null;
+}
+function ensureAbsolutePath(pointer, options) {
+    return (0, path_1.isAbsolute)(pointer) ? pointer : (0, path_1.resolve)(options.cwd || (0, process_1.cwd)(), pointer);
+}

package/cjs/load-from-module.js

@@ -0,0 +1,67 @@
+"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.tryToLoadFromExportSync = exports.tryToLoadFromExport = void 0;
+const exports_js_1 = require("./exports.js");
+/**
+ * @internal
+ */
+async function tryToLoadFromExport(rawFilePath) {
+    try {
+        const filepath = ensureFilepath(rawFilePath);
+        const mod = await Promise.resolve().then(() => __importStar(require(filepath)));
+        return await (0, exports_js_1.pickExportFromModule)({ module: mod, filepath });
+    }
+    catch (e) {
+        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
+    }
+}
+exports.tryToLoadFromExport = tryToLoadFromExport;
+/**
+ * @internal
+ */
+function tryToLoadFromExportSync(rawFilePath) {
+    try {
+        const filepath = ensureFilepath(rawFilePath);
+        const mod = require(filepath);
+        return (0, exports_js_1.pickExportFromModuleSync)({ module: mod, filepath });
+    }
+    catch (e) {
+        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
+    }
+}
+exports.tryToLoadFromExportSync = tryToLoadFromExportSync;
+/**
+ * @internal
+ */
+function ensureFilepath(filepath) {
+    if (typeof require !== 'undefined' && require.cache) {
+        filepath = require.resolve(filepath);
+        if (require.cache[filepath]) {
+            delete require.cache[filepath];
+        }
+    }
+    return filepath;
+}

package/cjs/package.json

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

package/esm/exports.js

@@ -0,0 +1,64 @@
+import { parse, buildClientSchema, isSchema } from 'graphql';
+import { isSchemaAst, isSchemaJson, isSchemaText, isWrappedSchemaJson, pick } from './helpers.js';
+const identifiersToLookFor = ['default', 'schema', 'typeDefs', 'data'];
+// Pick exports
+/**
+ * @internal
+ */
+export function pickExportFromModule({ module, filepath }) {
+    ensureModule({ module, filepath });
+    return resolveModule(ensureExports({ module, filepath }));
+}
+/**
+ * @internal
+ */
+export function pickExportFromModuleSync({ module, filepath }) {
+    ensureModule({ module, filepath });
+    return resolveModuleSync(ensureExports({ module, filepath }));
+}
+// module
+async function resolveModule(identifiers) {
+    const exportValue = await pick(await identifiers, identifiersToLookFor);
+    return resolveExport(exportValue);
+}
+function resolveModuleSync(identifiers) {
+    const exportValue = pick(identifiers, identifiersToLookFor);
+    return resolveExport(exportValue);
+}
+// validate
+function ensureModule({ module, filepath }) {
+    if (!module) {
+        throw new Error(`Invalid export from export file ${filepath}: empty export!`);
+    }
+}
+function ensureExports({ module, filepath }) {
+    const identifiers = pick(module, identifiersToLookFor);
+    if (!identifiers) {
+        throw new Error(`Invalid export from export file ${filepath}: missing default export or 'schema' export!`);
+    }
+    return identifiers;
+}
+// Decide what to do with an exported value
+function resolveExport(fileExport) {
+    try {
+        if (isSchema(fileExport)) {
+            return fileExport;
+        }
+        if (isSchemaText(fileExport)) {
+            return parse(fileExport);
+        }
+        if (isWrappedSchemaJson(fileExport)) {
+            return buildClientSchema(fileExport.data);
+        }
+        if (isSchemaJson(fileExport)) {
+            return buildClientSchema(fileExport);
+        }
+        if (isSchemaAst(fileExport)) {
+            return fileExport;
+        }
+        return null;
+    }
+    catch (e) {
+        throw new Error('Exported schema must be of type GraphQLSchema, text, AST, or introspection JSON.');
+    }
+}

package/esm/helpers.js

@@ -0,0 +1,38 @@
+/**
+ * @internal
+ */
+export function pick(obj, keys) {
+    for (const key of keys) {
+        if (obj[key]) {
+            return obj[key];
+        }
+    }
+    return obj;
+}
+// checkers
+/**
+ * @internal
+ */
+export function isSchemaText(obj) {
+    return typeof obj === 'string';
+}
+/**
+ * @internal
+ */
+export function isWrappedSchemaJson(obj) {
+    const json = obj;
+    return json.data !== undefined && json.data.__schema !== undefined;
+}
+/**
+ * @internal
+ */
+export function isSchemaJson(obj) {
+    const json = obj;
+    return json !== undefined && json.__schema !== undefined;
+}
+/**
+ * @internal
+ */
+export function isSchemaAst(obj) {
+    return obj.kind !== undefined;
+}

package/{index.mjs → esm/index.js}

@@ -1,155 +1,14 @@
-import { isSchema, parse, buildClientSchema } from 'graphql';
-import { isValidPath, asArray, AggregateError, parseGraphQLSDL, isDocumentNode } from '@graphql-tools/utils';
-import { gqlPluckFromCodeString, gqlPluckFromCodeStringSync } from '@graphql-tools/graphql-tag-pluck';
+import { isSchema, parse } from 'graphql';
+import { asArray, isValidPath, parseGraphQLSDL, isDocumentNode, AggregateError, } from '@graphql-tools/utils';
+import { gqlPluckFromCodeString, gqlPluckFromCodeStringSync, } from '@graphql-tools/graphql-tag-pluck';
 import globby from 'globby';
 import unixify from 'unixify';
+import { tryToLoadFromExport, tryToLoadFromExportSync } from './load-from-module.js';
 import { isAbsolute, resolve } from 'path';
 import { cwd, env } from 'process';
-import { existsSync, readFileSync, promises } from 'fs';
+import { readFileSync, promises as fsPromises, existsSync } from 'fs';
 import { createRequire } from 'module';
-
-/**
- * @internal
- */
-function pick(obj, keys) {
-    for (const key of keys) {
-        if (obj[key]) {
-            return obj[key];
-        }
-    }
-    return obj;
-}
-// checkers
-/**
- * @internal
- */
-function isSchemaText(obj) {
-    return typeof obj === 'string';
-}
-/**
- * @internal
- */
-function isWrappedSchemaJson(obj) {
-    const json = obj;
-    return json.data !== undefined && json.data.__schema !== undefined;
-}
-/**
- * @internal
- */
-function isSchemaJson(obj) {
-    const json = obj;
-    return json !== undefined && json.__schema !== undefined;
-}
-/**
- * @internal
- */
-function isSchemaAst(obj) {
-    return obj.kind !== undefined;
-}
-
-const identifiersToLookFor = ['default', 'schema', 'typeDefs', 'data'];
-// Pick exports
-/**
- * @internal
- */
-function pickExportFromModule({ module, filepath }) {
-    ensureModule({ module, filepath });
-    return resolveModule(ensureExports({ module, filepath }));
-}
-/**
- * @internal
- */
-function pickExportFromModuleSync({ module, filepath }) {
-    ensureModule({ module, filepath });
-    return resolveModuleSync(ensureExports({ module, filepath }));
-}
-// module
-async function resolveModule(identifiers) {
-    const exportValue = await pick(await identifiers, identifiersToLookFor);
-    return resolveExport(exportValue);
-}
-function resolveModuleSync(identifiers) {
-    const exportValue = pick(identifiers, identifiersToLookFor);
-    return resolveExport(exportValue);
-}
-// validate
-function ensureModule({ module, filepath }) {
-    if (!module) {
-        throw new Error(`Invalid export from export file ${filepath}: empty export!`);
-    }
-}
-function ensureExports({ module, filepath }) {
-    const identifiers = pick(module, identifiersToLookFor);
-    if (!identifiers) {
-        throw new Error(`Invalid export from export file ${filepath}: missing default export or 'schema' export!`);
-    }
-    return identifiers;
-}
-// Decide what to do with an exported value
-function resolveExport(fileExport) {
-    try {
-        if (isSchema(fileExport)) {
-            return fileExport;
-        }
-        if (isSchemaText(fileExport)) {
-            return parse(fileExport);
-        }
-        if (isWrappedSchemaJson(fileExport)) {
-            return buildClientSchema(fileExport.data);
-        }
-        if (isSchemaJson(fileExport)) {
-            return buildClientSchema(fileExport);
-        }
-        if (isSchemaAst(fileExport)) {
-            return fileExport;
-        }
-        return null;
-    }
-    catch (e) {
-        throw new Error('Exported schema must be of type GraphQLSchema, text, AST, or introspection JSON.');
-    }
-}
-
-/**
- * @internal
- */
-async function tryToLoadFromExport(rawFilePath) {
-    try {
-        const filepath = ensureFilepath(rawFilePath);
-        const mod = await import(filepath);
-        return await pickExportFromModule({ module: mod, filepath });
-    }
-    catch (e) {
-        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
-    }
-}
-/**
- * @internal
- */
-function tryToLoadFromExportSync(rawFilePath) {
-    try {
-        const filepath = ensureFilepath(rawFilePath);
-        const mod = require(filepath);
-        return pickExportFromModuleSync({ module: mod, filepath });
-    }
-    catch (e) {
-        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
-    }
-}
-/**
- * @internal
- */
-function ensureFilepath(filepath) {
-    if (typeof require !== 'undefined' && require.cache) {
-        filepath = require.resolve(filepath);
-        if (require.cache[filepath]) {
-            delete require.cache[filepath];
-        }
-    }
-    return filepath;
-}
-
-const { readFile, access } = promises;
+const { readFile, access } = fsPromises;
 const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.svelte'];
 function createGlobbyOptions(options) {
     return { absolute: true, ...options, ignore: [] };
@@ -169,7 +28,7 @@ const buildIgnoreGlob = (path) => `!${path}`;
  *
  * Supported extensions include: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`
  */
-class CodeFileLoader {
+export class CodeFileLoader {
     constructor(config) {
         this.config = config !== null && config !== void 0 ? config : {};
     }
@@ -390,5 +249,3 @@ function resolveSource(pointer, value, options) {
 function ensureAbsolutePath(pointer, options) {
     return isAbsolute(pointer) ? pointer : resolve(options.cwd || cwd(), pointer);
 }
-
-export { CodeFileLoader };

package/esm/load-from-module.js

@@ -0,0 +1,39 @@
+import { pickExportFromModule, pickExportFromModuleSync } from './exports.js';
+/**
+ * @internal
+ */
+export async function tryToLoadFromExport(rawFilePath) {
+    try {
+        const filepath = ensureFilepath(rawFilePath);
+        const mod = await import(filepath);
+        return await pickExportFromModule({ module: mod, filepath });
+    }
+    catch (e) {
+        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
+    }
+}
+/**
+ * @internal
+ */
+export function tryToLoadFromExportSync(rawFilePath) {
+    try {
+        const filepath = ensureFilepath(rawFilePath);
+        const mod = require(filepath);
+        return pickExportFromModuleSync({ module: mod, filepath });
+    }
+    catch (e) {
+        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
+    }
+}
+/**
+ * @internal
+ */
+function ensureFilepath(filepath) {
+    if (typeof require !== 'undefined' && require.cache) {
+        filepath = require.resolve(filepath);
+        if (require.cache[filepath]) {
+            delete require.cache[filepath];
+        }
+    }
+    return filepath;
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/code-file-loader",
-  "version": "7.2.19",
+  "version": "7.3.0-alpha-6c480b2d.0",
   "description": "A set of utils for faster development of GraphQL tools",
   "sideEffects": false,
   "peerDependencies": {
     "graphql": "^14.0.0 || ^15.0.0 || ^16.0.0 || ^17.0.0"
   },
   "dependencies": {
-    "@graphql-tools/graphql-tag-pluck": "7.2.11",
-    "@graphql-tools/utils": "8.7.0",
+    "@graphql-tools/utils": "8.8.0-alpha-6c480b2d.0",
+    "@graphql-tools/graphql-tag-pluck": "7.3.0-alpha-6c480b2d.0",
     "globby": "^11.0.3",
     "tslib": "^2.4.0",
     "unixify": "^1.0.0"
@@ -20,21 +20,42 @@
   },
   "author": "Dotan Simha <dotansimha@gmail.com>",
   "license": "MIT",
-  "main": "index.js",
-  "module": "index.mjs",
-  "typings": "index.d.ts",
+  "main": "cjs/index.js",
+  "module": "esm/index.js",
+  "typings": "typings/index.d.ts",
   "typescript": {
-    "definition": "index.d.ts"
+    "definition": "typings/index.d.ts"
   },
+  "type": "module",
   "exports": {
     ".": {
-      "require": "./index.js",
-      "import": "./index.mjs"
+      "require": {
+        "types": "./typings/index.d.ts",
+        "default": "./cjs/index.js"
+      },
+      "import": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      },
+      "default": {
+        "types": "./typings/index.d.ts",
+        "default": "./esm/index.js"
+      }
     },
     "./*": {
-      "require": "./*.js",
-      "import": "./*.mjs"
+      "require": {
+        "types": "./typings/*.d.ts",
+        "default": "./cjs/*.js"
+      },
+      "import": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      },
+      "default": {
+        "types": "./typings/*.d.ts",
+        "default": "./esm/*.js"
+      }
     },
     "./package.json": "./package.json"
   }
-}
+}

package/index.js

@@ -1,419 +0,0 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-function _interopNamespace(e) {
-    if (e && e.__esModule) { return e; } else {
-        var n = {};
-        if (e) {
-            Object.keys(e).forEach(function (k) {
-                var d = Object.getOwnPropertyDescriptor(e, k);
-                Object.defineProperty(n, k, d.get ? d : {
-                    enumerable: true,
-                    get: function () {
-                        return e[k];
-                    }
-                });
-            });
-        }
-        n['default'] = e;
-        return n;
-    }
-}
-
-const graphql = require('graphql');
-const utils = require('@graphql-tools/utils');
-const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
-const globby = _interopDefault(require('globby'));
-const unixify = _interopDefault(require('unixify'));
-const path = require('path');
-const process = require('process');
-const fs = require('fs');
-const module$1 = require('module');
-
-/**
- * @internal
- */
-function pick(obj, keys) {
-    for (const key of keys) {
-        if (obj[key]) {
-            return obj[key];
-        }
-    }
-    return obj;
-}
-// checkers
-/**
- * @internal
- */
-function isSchemaText(obj) {
-    return typeof obj === 'string';
-}
-/**
- * @internal
- */
-function isWrappedSchemaJson(obj) {
-    const json = obj;
-    return json.data !== undefined && json.data.__schema !== undefined;
-}
-/**
- * @internal
- */
-function isSchemaJson(obj) {
-    const json = obj;
-    return json !== undefined && json.__schema !== undefined;
-}
-/**
- * @internal
- */
-function isSchemaAst(obj) {
-    return obj.kind !== undefined;
-}
-
-const identifiersToLookFor = ['default', 'schema', 'typeDefs', 'data'];
-// Pick exports
-/**
- * @internal
- */
-function pickExportFromModule({ module, filepath }) {
-    ensureModule({ module, filepath });
-    return resolveModule(ensureExports({ module, filepath }));
-}
-/**
- * @internal
- */
-function pickExportFromModuleSync({ module, filepath }) {
-    ensureModule({ module, filepath });
-    return resolveModuleSync(ensureExports({ module, filepath }));
-}
-// module
-async function resolveModule(identifiers) {
-    const exportValue = await pick(await identifiers, identifiersToLookFor);
-    return resolveExport(exportValue);
-}
-function resolveModuleSync(identifiers) {
-    const exportValue = pick(identifiers, identifiersToLookFor);
-    return resolveExport(exportValue);
-}
-// validate
-function ensureModule({ module, filepath }) {
-    if (!module) {
-        throw new Error(`Invalid export from export file ${filepath}: empty export!`);
-    }
-}
-function ensureExports({ module, filepath }) {
-    const identifiers = pick(module, identifiersToLookFor);
-    if (!identifiers) {
-        throw new Error(`Invalid export from export file ${filepath}: missing default export or 'schema' export!`);
-    }
-    return identifiers;
-}
-// Decide what to do with an exported value
-function resolveExport(fileExport) {
-    try {
-        if (graphql.isSchema(fileExport)) {
-            return fileExport;
-        }
-        if (isSchemaText(fileExport)) {
-            return graphql.parse(fileExport);
-        }
-        if (isWrappedSchemaJson(fileExport)) {
-            return graphql.buildClientSchema(fileExport.data);
-        }
-        if (isSchemaJson(fileExport)) {
-            return graphql.buildClientSchema(fileExport);
-        }
-        if (isSchemaAst(fileExport)) {
-            return fileExport;
-        }
-        return null;
-    }
-    catch (e) {
-        throw new Error('Exported schema must be of type GraphQLSchema, text, AST, or introspection JSON.');
-    }
-}
-
-/**
- * @internal
- */
-async function tryToLoadFromExport(rawFilePath) {
-    try {
-        const filepath = ensureFilepath(rawFilePath);
-        const mod = await new Promise(function (resolve) { resolve(_interopNamespace(require(filepath))); });
-        return await pickExportFromModule({ module: mod, filepath });
-    }
-    catch (e) {
-        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
-    }
-}
-/**
- * @internal
- */
-function tryToLoadFromExportSync(rawFilePath) {
-    try {
-        const filepath = ensureFilepath(rawFilePath);
-        const mod = require(filepath);
-        return pickExportFromModuleSync({ module: mod, filepath });
-    }
-    catch (e) {
-        throw new Error(`Unable to load from file "${rawFilePath}": ${e.stack || e.message}`);
-    }
-}
-/**
- * @internal
- */
-function ensureFilepath(filepath) {
-    if (typeof require !== 'undefined' && require.cache) {
-        filepath = require.resolve(filepath);
-        if (require.cache[filepath]) {
-            delete require.cache[filepath];
-        }
-    }
-    return filepath;
-}
-
-const { readFile, access } = fs.promises;
-const FILE_EXTENSIONS = ['.ts', '.tsx', '.js', '.jsx', '.vue', '.svelte'];
-function createGlobbyOptions(options) {
-    return { absolute: true, ...options, ignore: [] };
-}
-const buildIgnoreGlob = (path) => `!${path}`;
-/**
- * This loader loads GraphQL documents and type definitions from code files
- * using `graphql-tag-pluck`.
- *
- * ```js
- * const documents = await loadDocuments('queries/*.js', {
- *   loaders: [
- *     new CodeFileLoader()
- *   ]
- * });
- * ```
- *
- * Supported extensions include: `.ts`, `.tsx`, `.js`, `.jsx`, `.vue`, `.svelte`
- */
-class CodeFileLoader {
-    constructor(config) {
-        this.config = config !== null && config !== void 0 ? config : {};
-    }
-    getMergedOptions(options) {
-        return { ...this.config, ...options };
-    }
-    async canLoad(pointer, options) {
-        options = this.getMergedOptions(options);
-        if (utils.isValidPath(pointer)) {
-            if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
-                const normalizedFilePath = path.isAbsolute(pointer) ? pointer : path.resolve(options.cwd || process.cwd(), pointer);
-                try {
-                    await access(normalizedFilePath);
-                    return true;
-                }
-                catch (_a) {
-                    return false;
-                }
-            }
-        }
-        return false;
-    }
-    canLoadSync(pointer, options) {
-        options = this.getMergedOptions(options);
-        if (utils.isValidPath(pointer)) {
-            if (FILE_EXTENSIONS.find(extension => pointer.endsWith(extension))) {
-                const normalizedFilePath = path.isAbsolute(pointer) ? pointer : path.resolve(options.cwd || process.cwd(), pointer);
-                return fs.existsSync(normalizedFilePath);
-            }
-        }
-        return false;
-    }
-    _buildGlobs(glob, options) {
-        const ignores = utils.asArray(options.ignore || []);
-        const globs = [unixify(glob), ...ignores.map(v => buildIgnoreGlob(unixify(v)))];
-        return globs;
-    }
-    async resolveGlobs(glob, options) {
-        options = this.getMergedOptions(options);
-        const globs = this._buildGlobs(glob, options);
-        return globby(globs, createGlobbyOptions(options));
-    }
-    resolveGlobsSync(glob, options) {
-        options = this.getMergedOptions(options);
-        const globs = this._buildGlobs(glob, options);
-        return globby.sync(globs, createGlobbyOptions(options));
-    }
-    async load(pointer, options) {
-        options = this.getMergedOptions(options);
-        const resolvedPaths = await this.resolveGlobs(pointer, options);
-        const finalResult = [];
-        const errors = [];
-        await Promise.all(resolvedPaths.map(async (path) => {
-            try {
-                const result = await this.handleSinglePath(path, options);
-                result === null || result === void 0 ? void 0 : result.forEach(result => finalResult.push(result));
-            }
-            catch (e) {
-                if (process.env['DEBUG']) {
-                    console.error(e);
-                }
-                errors.push(e);
-            }
-        }));
-        if (errors.length > 0 && (options.noSilentErrors || finalResult.length === 0)) {
-            if (errors.length === 1) {
-                throw errors[0];
-            }
-            throw new utils.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
-        }
-        return finalResult;
-    }
-    loadSync(pointer, options) {
-        options = this.getMergedOptions(options);
-        const resolvedPaths = this.resolveGlobsSync(pointer, options);
-        const finalResult = [];
-        const errors = [];
-        for (const path of resolvedPaths) {
-            if (this.canLoadSync(path, options)) {
-                try {
-                    const result = this.handleSinglePathSync(path, options);
-                    result === null || result === void 0 ? void 0 : result.forEach(result => finalResult.push(result));
-                }
-                catch (e) {
-                    if (process.env['DEBUG']) {
-                        console.error(e);
-                    }
-                    errors.push(e);
-                }
-            }
-        }
-        if (errors.length > 0 && (options.noSilentErrors || finalResult.length === 0)) {
-            if (errors.length === 1) {
-                throw errors[0];
-            }
-            throw new utils.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
-        }
-        return finalResult;
-    }
-    async handleSinglePath(location, options) {
-        if (!(await this.canLoad(location, options))) {
-            return [];
-        }
-        options = this.getMergedOptions(options);
-        const normalizedFilePath = ensureAbsolutePath(location, options);
-        const errors = [];
-        if (!options.noPluck) {
-            try {
-                const content = await readFile(normalizedFilePath, { encoding: 'utf-8' });
-                const sources = await graphqlTagPluck.gqlPluckFromCodeString(normalizedFilePath, content, options.pluckConfig);
-                if (sources.length) {
-                    return sources.map(source => ({
-                        rawSDL: source.body,
-                        document: graphql.parse(source),
-                        location,
-                    }));
-                }
-            }
-            catch (e) {
-                if (process.env['DEBUG']) {
-                    console.error(`Failed to load schema from code file "${normalizedFilePath}": ${e.message}`);
-                }
-                errors.push(e);
-            }
-        }
-        if (!options.noRequire) {
-            try {
-                if (options && options.require) {
-                    await Promise.all(utils.asArray(options.require).map(m => new Promise(function (resolve) { resolve(_interopNamespace(require(m))); })));
-                }
-                const loaded = await tryToLoadFromExport(normalizedFilePath);
-                const sources = utils.asArray(loaded)
-                    .map(value => resolveSource(location, value, options))
-                    .filter(Boolean);
-                if (sources.length) {
-                    return sources;
-                }
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        }
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        return [];
-    }
-    handleSinglePathSync(location, options) {
-        if (!this.canLoadSync(location, options)) {
-            return [];
-        }
-        options = this.getMergedOptions(options);
-        const normalizedFilePath = ensureAbsolutePath(location, options);
-        const errors = [];
-        if (!options.noPluck) {
-            try {
-                const content = fs.readFileSync(normalizedFilePath, { encoding: 'utf-8' });
-                const sources = graphqlTagPluck.gqlPluckFromCodeStringSync(normalizedFilePath, content, options.pluckConfig);
-                if (sources.length) {
-                    return sources.map(source => ({
-                        rawSDL: source.body,
-                        document: graphql.parse(source),
-                        location,
-                    }));
-                }
-            }
-            catch (e) {
-                if (process.env['DEBUG']) {
-                    console.error(`Failed to load schema from code file "${normalizedFilePath}": ${e.message}`);
-                }
-                errors.push(e);
-            }
-        }
-        if (!options.noRequire) {
-            try {
-                if (options && options.require) {
-                    const cwdRequire = module$1.createRequire(options.cwd || process.cwd());
-                    for (const m of utils.asArray(options.require)) {
-                        cwdRequire(m);
-                    }
-                }
-                const loaded = tryToLoadFromExportSync(normalizedFilePath);
-                const sources = utils.asArray(loaded)
-                    .map(value => resolveSource(location, value, options))
-                    .filter(Boolean);
-                if (sources.length) {
-                    return sources;
-                }
-            }
-            catch (e) {
-                errors.push(e);
-            }
-        }
-        if (errors.length > 0) {
-            throw errors[0];
-        }
-        return null;
-    }
-}
-function resolveSource(pointer, value, options) {
-    if (typeof value === 'string') {
-        return utils.parseGraphQLSDL(pointer, value, options);
-    }
-    else if (graphql.isSchema(value)) {
-        return {
-            location: pointer,
-            schema: value,
-        };
-    }
-    else if (utils.isDocumentNode(value)) {
-        return {
-            location: pointer,
-            document: value,
-        };
-    }
-    return null;
-}
-function ensureAbsolutePath(pointer, options) {
-    return path.isAbsolute(pointer) ? pointer : path.resolve(options.cwd || process.cwd(), pointer);
-}
-
-exports.CodeFileLoader = CodeFileLoader;