@graphql-tools/git-loader 7.1.18-alpha-b3ffd406.0 → 7.2.0-alpha-b76ec274.0

package/{index.js → cjs/index.js}

@@ -1,104 +1,16 @@
-'use strict';
-
-Object.defineProperty(exports, '__esModule', { value: true });
-
-function _interopDefault (ex) { return (ex && (typeof ex === 'object') && 'default' in ex) ? ex['default'] : ex; }
-
-const graphqlTagPluck = require('@graphql-tools/graphql-tag-pluck');
-const micromatch = _interopDefault(require('micromatch'));
-const unixify = _interopDefault(require('unixify'));
-const child_process = require('child_process');
-const os = _interopDefault(require('os'));
-const utils = require('@graphql-tools/utils');
-const graphql = require('graphql');
-const isGlob = _interopDefault(require('is-glob'));
-const process = require('process');
-
-const createLoadError = (error) => new Error('Unable to load file from git: ' + error);
-const createShowCommand = ({ ref, path }) => {
-    return ['show', `${ref}:${path}`];
-};
-const createTreeError = (error) => new Error('Unable to load the file tree from git: ' + error);
-const createTreeCommand = ({ ref }) => {
-    return ['ls-tree', '-r', '--name-only', ref];
-};
-/**
- * @internal
- */
-async function readTreeAtRef(ref) {
-    try {
-        return await new Promise((resolve, reject) => {
-            child_process.execFile('git', createTreeCommand({ ref }), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(stdout.split(os.EOL).map(line => line.trim()));
-                }
-            });
-        });
-    }
-    catch (error) {
-        throw createTreeError(error);
-    }
-}
-/**
- * @internal
- */
-function readTreeAtRefSync(ref) {
-    try {
-        return child_process.execFileSync('git', createTreeCommand({ ref }), { encoding: 'utf-8' })
-            .split(os.EOL)
-            .map(line => line.trim());
-    }
-    catch (error) {
-        throw createTreeError(error);
-    }
-}
-/**
- * @internal
- */
-async function loadFromGit(input) {
-    try {
-        return await new Promise((resolve, reject) => {
-            child_process.execFile('git', createShowCommand(input), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(stdout);
-                }
-            });
-        });
-    }
-    catch (error) {
-        throw createLoadError(error);
-    }
-}
-/**
- * @internal
- */
-function loadFromGitSync(input) {
-    try {
-        return child_process.execFileSync('git', createShowCommand(input), { encoding: 'utf-8' });
-    }
-    catch (error) {
-        throw createLoadError(error);
-    }
-}
-
-/**
- * @internal
- */
-function parse({ path, pointer, content, options, }) {
-    if (/\.(gql|graphql)s?$/i.test(path)) {
-        return utils.parseGraphQLSDL(pointer, content, options);
-    }
-    if (/\.json$/i.test(path)) {
-        return utils.parseGraphQLJSON(pointer, content, options);
-    }
-}
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GitLoader = void 0;
+const tslib_1 = require("tslib");
+const graphql_tag_pluck_1 = require("@graphql-tools/graphql-tag-pluck");
+const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
+const unixify_1 = tslib_1.__importDefault(require("unixify"));
+const load_git_js_1 = require("./load-git.js");
+const parse_js_1 = require("./parse.js");
+const graphql_1 = require("graphql");
+const utils_1 = require("@graphql-tools/utils");
+const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
+const process_1 = require("process");
 // git:branch:path/to/file
 function extractData(pointer) {
     const parts = pointer.replace(/^git\:/i, '').split(':');
@@ -136,7 +48,7 @@ class GitLoader {
         if (!refsForPaths.has(ref)) {
             refsForPaths.set(ref, []);
         }
-        refsForPaths.get(ref).push(unixify(path));
+        refsForPaths.get(ref).push((0, unixify_1.default)(path));
         for (const ignore of ignores) {
             const data = extractData(ignore);
             if (data === null) {
@@ -146,11 +58,11 @@ class GitLoader {
             if (!refsForPaths.has(ref)) {
                 refsForPaths.set(ref, []);
             }
-            refsForPaths.get(ref).push(`!${unixify(path)}`);
+            refsForPaths.get(ref).push(`!${(0, unixify_1.default)(path)}`);
         }
         const resolved = [];
         await Promise.all([...refsForPaths.entries()].map(async ([ref, paths]) => {
-            resolved.push(...micromatch(await readTreeAtRef(ref), paths).map(filePath => `git:${ref}:${filePath}`));
+            resolved.push(...(0, micromatch_1.default)(await (0, load_git_js_1.readTreeAtRef)(ref), paths).map(filePath => `git:${ref}:${filePath}`));
         }));
         return resolved;
     }
@@ -164,7 +76,7 @@ class GitLoader {
         if (!refsForPaths.has(ref)) {
             refsForPaths.set(ref, []);
         }
-        refsForPaths.get(ref).push(unixify(path));
+        refsForPaths.get(ref).push((0, unixify_1.default)(path));
         for (const ignore of ignores) {
             const data = extractData(ignore);
             if (data === null) {
@@ -174,11 +86,11 @@ class GitLoader {
             if (!refsForPaths.has(ref)) {
                 refsForPaths.set(ref, []);
             }
-            refsForPaths.get(ref).push(`!${unixify(path)}`);
+            refsForPaths.get(ref).push(`!${(0, unixify_1.default)(path)}`);
         }
         const resolved = [];
         for (const [ref, paths] of refsForPaths.entries()) {
-            resolved.push(...micromatch(readTreeAtRefSync(ref), paths).map(filePath => `git:${ref}:${filePath}`));
+            resolved.push(...(0, micromatch_1.default)((0, load_git_js_1.readTreeAtRefSync)(ref), paths).map(filePath => `git:${ref}:${filePath}`));
         }
         return resolved;
     }
@@ -188,15 +100,15 @@ class GitLoader {
             return [];
         }
         const { ref, path } = result;
-        const content = await loadFromGit({ ref, path });
-        const parsed = parse({ path, options, pointer, content });
+        const content = await (0, load_git_js_1.loadFromGit)({ ref, path });
+        const parsed = (0, parse_js_1.parse)({ path, options, pointer, content });
         if (parsed) {
             return [parsed];
         }
-        const sources = await graphqlTagPluck.gqlPluckFromCodeString(pointer, content, options.pluckConfig);
+        const sources = await (0, graphql_tag_pluck_1.gqlPluckFromCodeString)(pointer, content, options.pluckConfig);
         return sources.map(source => ({
             location: pointer,
-            document: graphql.parse(source, options),
+            document: (0, graphql_1.parse)(source, options),
         }));
     }
     async load(pointer, options) {
@@ -208,8 +120,8 @@ class GitLoader {
         const finalResult = [];
         const errors = [];
         try {
-            if (isGlob(path)) {
-                const resolvedPaths = await this.resolveGlobs(pointer, utils.asArray(options.ignore || []));
+            if ((0, is_glob_1.default)(path)) {
+                const resolvedPaths = await this.resolveGlobs(pointer, (0, utils_1.asArray)(options.ignore || []));
                 await Promise.all(resolvedPaths.map(async (path) => {
                     const results = await this.load(path, options);
                     results === null || results === void 0 ? void 0 : results.forEach(result => finalResult.push(result));
@@ -221,10 +133,10 @@ class GitLoader {
             }
         }
         catch (error) {
-            if (process.env['DEBUG']) {
+            if (process_1.env['DEBUG']) {
                 console.error(error);
             }
-            if (error instanceof utils.AggregateError) {
+            if (error instanceof utils_1.AggregateError) {
                 for (const errorElement of error.errors) {
                     errors.push(errorElement);
                 }
@@ -237,7 +149,7 @@ class GitLoader {
             if (errors.length === 1) {
                 throw errors[0];
             }
-            throw new utils.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
+            throw new utils_1.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
         }
         return finalResult;
     }
@@ -247,15 +159,15 @@ class GitLoader {
             return [];
         }
         const { ref, path } = result;
-        const content = loadFromGitSync({ ref, path });
-        const parsed = parse({ path, options, pointer, content });
+        const content = (0, load_git_js_1.loadFromGitSync)({ ref, path });
+        const parsed = (0, parse_js_1.parse)({ path, options, pointer, content });
         if (parsed) {
             return [parsed];
         }
-        const sources = graphqlTagPluck.gqlPluckFromCodeStringSync(pointer, content, options.pluckConfig);
+        const sources = (0, graphql_tag_pluck_1.gqlPluckFromCodeStringSync)(pointer, content, options.pluckConfig);
         return sources.map(source => ({
             location: pointer,
-            document: graphql.parse(source, options),
+            document: (0, graphql_1.parse)(source, options),
         }));
     }
     loadSync(pointer, options) {
@@ -267,8 +179,8 @@ class GitLoader {
         const finalResult = [];
         const errors = [];
         try {
-            if (isGlob(path)) {
-                const resolvedPaths = this.resolveGlobsSync(pointer, utils.asArray(options.ignore || []));
+            if ((0, is_glob_1.default)(path)) {
+                const resolvedPaths = this.resolveGlobsSync(pointer, (0, utils_1.asArray)(options.ignore || []));
                 const finalResult = [];
                 for (const path of resolvedPaths) {
                     if (this.canLoadSync(path)) {
@@ -287,10 +199,10 @@ class GitLoader {
             }
         }
         catch (error) {
-            if (process.env['DEBUG']) {
+            if (process_1.env['DEBUG']) {
                 console.error(error);
             }
-            if (error instanceof utils.AggregateError) {
+            if (error instanceof utils_1.AggregateError) {
                 for (const errorElement of error.errors) {
                     errors.push(errorElement);
                 }
@@ -303,10 +215,9 @@ class GitLoader {
             if (errors.length === 1) {
                 throw errors[0];
             }
-            throw new utils.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
+            throw new utils_1.AggregateError(errors, `Reading from ${pointer} failed ; \n ` + errors.map((e) => e.message).join('\n'));
         }
         return finalResult;
     }
 }
-
 exports.GitLoader = GitLoader;

package/cjs/load-git.js

@@ -0,0 +1,82 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.loadFromGitSync = exports.loadFromGit = exports.readTreeAtRefSync = exports.readTreeAtRef = void 0;
+const tslib_1 = require("tslib");
+const child_process_1 = require("child_process");
+const os_1 = tslib_1.__importDefault(require("os"));
+const createLoadError = (error) => new Error('Unable to load file from git: ' + error);
+const createShowCommand = ({ ref, path }) => {
+    return ['show', `${ref}:${path}`];
+};
+const createTreeError = (error) => new Error('Unable to load the file tree from git: ' + error);
+const createTreeCommand = ({ ref }) => {
+    return ['ls-tree', '-r', '--name-only', ref];
+};
+/**
+ * @internal
+ */
+async function readTreeAtRef(ref) {
+    try {
+        return await new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('git', createTreeCommand({ ref }), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout.split(os_1.default.EOL).map(line => line.trim()));
+                }
+            });
+        });
+    }
+    catch (error) {
+        throw createTreeError(error);
+    }
+}
+exports.readTreeAtRef = readTreeAtRef;
+/**
+ * @internal
+ */
+function readTreeAtRefSync(ref) {
+    try {
+        return (0, child_process_1.execFileSync)('git', createTreeCommand({ ref }), { encoding: 'utf-8' })
+            .split(os_1.default.EOL)
+            .map(line => line.trim());
+    }
+    catch (error) {
+        throw createTreeError(error);
+    }
+}
+exports.readTreeAtRefSync = readTreeAtRefSync;
+/**
+ * @internal
+ */
+async function loadFromGit(input) {
+    try {
+        return await new Promise((resolve, reject) => {
+            (0, child_process_1.execFile)('git', createShowCommand(input), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+    }
+    catch (error) {
+        throw createLoadError(error);
+    }
+}
+exports.loadFromGit = loadFromGit;
+/**
+ * @internal
+ */
+function loadFromGitSync(input) {
+    try {
+        return (0, child_process_1.execFileSync)('git', createShowCommand(input), { encoding: 'utf-8' });
+    }
+    catch (error) {
+        throw createLoadError(error);
+    }
+}
+exports.loadFromGitSync = loadFromGitSync;

package/cjs/package.json

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

package/cjs/parse.js

@@ -0,0 +1,16 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.parse = void 0;
+const utils_1 = require("@graphql-tools/utils");
+/**
+ * @internal
+ */
+function parse({ path, pointer, content, options, }) {
+    if (/\.(gql|graphql)s?$/i.test(path)) {
+        return (0, utils_1.parseGraphQLSDL)(pointer, content, options);
+    }
+    if (/\.json$/i.test(path)) {
+        return (0, utils_1.parseGraphQLJSON)(pointer, content, options);
+    }
+}
+exports.parse = parse;

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

@@ -1,98 +1,12 @@
-import { gqlPluckFromCodeString, gqlPluckFromCodeStringSync } from '@graphql-tools/graphql-tag-pluck';
+import { gqlPluckFromCodeString, gqlPluckFromCodeStringSync, } from '@graphql-tools/graphql-tag-pluck';
 import micromatch from 'micromatch';
 import unixify from 'unixify';
-import { execFile, execFileSync } from 'child_process';
-import os from 'os';
-import { parseGraphQLSDL, parseGraphQLJSON, asArray, AggregateError } from '@graphql-tools/utils';
-import { parse as parse$1 } from 'graphql';
+import { loadFromGit, loadFromGitSync, readTreeAtRef, readTreeAtRefSync } from './load-git.js';
+import { parse as handleStuff } from './parse.js';
+import { parse } from 'graphql';
+import { asArray, AggregateError } from '@graphql-tools/utils';
 import isGlob from 'is-glob';
 import { env } from 'process';
-
-const createLoadError = (error) => new Error('Unable to load file from git: ' + error);
-const createShowCommand = ({ ref, path }) => {
-    return ['show', `${ref}:${path}`];
-};
-const createTreeError = (error) => new Error('Unable to load the file tree from git: ' + error);
-const createTreeCommand = ({ ref }) => {
-    return ['ls-tree', '-r', '--name-only', ref];
-};
-/**
- * @internal
- */
-async function readTreeAtRef(ref) {
-    try {
-        return await new Promise((resolve, reject) => {
-            execFile('git', createTreeCommand({ ref }), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(stdout.split(os.EOL).map(line => line.trim()));
-                }
-            });
-        });
-    }
-    catch (error) {
-        throw createTreeError(error);
-    }
-}
-/**
- * @internal
- */
-function readTreeAtRefSync(ref) {
-    try {
-        return execFileSync('git', createTreeCommand({ ref }), { encoding: 'utf-8' })
-            .split(os.EOL)
-            .map(line => line.trim());
-    }
-    catch (error) {
-        throw createTreeError(error);
-    }
-}
-/**
- * @internal
- */
-async function loadFromGit(input) {
-    try {
-        return await new Promise((resolve, reject) => {
-            execFile('git', createShowCommand(input), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
-                if (error) {
-                    reject(error);
-                }
-                else {
-                    resolve(stdout);
-                }
-            });
-        });
-    }
-    catch (error) {
-        throw createLoadError(error);
-    }
-}
-/**
- * @internal
- */
-function loadFromGitSync(input) {
-    try {
-        return execFileSync('git', createShowCommand(input), { encoding: 'utf-8' });
-    }
-    catch (error) {
-        throw createLoadError(error);
-    }
-}
-
-/**
- * @internal
- */
-function parse({ path, pointer, content, options, }) {
-    if (/\.(gql|graphql)s?$/i.test(path)) {
-        return parseGraphQLSDL(pointer, content, options);
-    }
-    if (/\.json$/i.test(path)) {
-        return parseGraphQLJSON(pointer, content, options);
-    }
-}
-
 // git:branch:path/to/file
 function extractData(pointer) {
     const parts = pointer.replace(/^git\:/i, '').split(':');
@@ -113,7 +27,7 @@ function extractData(pointer) {
  * })
  * ```
  */
-class GitLoader {
+export class GitLoader {
     async canLoad(pointer) {
         return this.canLoadSync(pointer);
     }
@@ -183,14 +97,14 @@ class GitLoader {
         }
         const { ref, path } = result;
         const content = await loadFromGit({ ref, path });
-        const parsed = parse({ path, options, pointer, content });
+        const parsed = handleStuff({ path, options, pointer, content });
         if (parsed) {
             return [parsed];
         }
         const sources = await gqlPluckFromCodeString(pointer, content, options.pluckConfig);
         return sources.map(source => ({
             location: pointer,
-            document: parse$1(source, options),
+            document: parse(source, options),
         }));
     }
     async load(pointer, options) {
@@ -242,14 +156,14 @@ class GitLoader {
         }
         const { ref, path } = result;
         const content = loadFromGitSync({ ref, path });
-        const parsed = parse({ path, options, pointer, content });
+        const parsed = handleStuff({ path, options, pointer, content });
         if (parsed) {
             return [parsed];
         }
         const sources = gqlPluckFromCodeStringSync(pointer, content, options.pluckConfig);
         return sources.map(source => ({
             location: pointer,
-            document: parse$1(source, options),
+            document: parse(source, options),
         }));
     }
     loadSync(pointer, options) {
@@ -302,5 +216,3 @@ class GitLoader {
         return finalResult;
     }
 }
-
-export { GitLoader };

package/esm/load-git.js

@@ -0,0 +1,74 @@
+import { execFile, execFileSync } from 'child_process';
+import os from 'os';
+const createLoadError = (error) => new Error('Unable to load file from git: ' + error);
+const createShowCommand = ({ ref, path }) => {
+    return ['show', `${ref}:${path}`];
+};
+const createTreeError = (error) => new Error('Unable to load the file tree from git: ' + error);
+const createTreeCommand = ({ ref }) => {
+    return ['ls-tree', '-r', '--name-only', ref];
+};
+/**
+ * @internal
+ */
+export async function readTreeAtRef(ref) {
+    try {
+        return await new Promise((resolve, reject) => {
+            execFile('git', createTreeCommand({ ref }), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout.split(os.EOL).map(line => line.trim()));
+                }
+            });
+        });
+    }
+    catch (error) {
+        throw createTreeError(error);
+    }
+}
+/**
+ * @internal
+ */
+export function readTreeAtRefSync(ref) {
+    try {
+        return execFileSync('git', createTreeCommand({ ref }), { encoding: 'utf-8' })
+            .split(os.EOL)
+            .map(line => line.trim());
+    }
+    catch (error) {
+        throw createTreeError(error);
+    }
+}
+/**
+ * @internal
+ */
+export async function loadFromGit(input) {
+    try {
+        return await new Promise((resolve, reject) => {
+            execFile('git', createShowCommand(input), { encoding: 'utf-8', maxBuffer: 1024 * 1024 * 1024 }, (error, stdout) => {
+                if (error) {
+                    reject(error);
+                }
+                else {
+                    resolve(stdout);
+                }
+            });
+        });
+    }
+    catch (error) {
+        throw createLoadError(error);
+    }
+}
+/**
+ * @internal
+ */
+export function loadFromGitSync(input) {
+    try {
+        return execFileSync('git', createShowCommand(input), { encoding: 'utf-8' });
+    }
+    catch (error) {
+        throw createLoadError(error);
+    }
+}

package/esm/parse.js

@@ -0,0 +1,12 @@
+import { parseGraphQLSDL, parseGraphQLJSON } from '@graphql-tools/utils';
+/**
+ * @internal
+ */
+export function parse({ path, pointer, content, options, }) {
+    if (/\.(gql|graphql)s?$/i.test(path)) {
+        return parseGraphQLSDL(pointer, content, options);
+    }
+    if (/\.json$/i.test(path)) {
+        return parseGraphQLJSON(pointer, content, options);
+    }
+}

package/package.json

@@ -1,14 +1,14 @@
 {
   "name": "@graphql-tools/git-loader",
-  "version": "7.1.18-alpha-b3ffd406.0",
+  "version": "7.2.0-alpha-b76ec274.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-alpha-b3ffd406.0",
-    "@graphql-tools/utils": "8.7.0-alpha-b3ffd406.0",
+    "@graphql-tools/graphql-tag-pluck": "7.3.0-alpha-b76ec274.0",
+    "@graphql-tools/utils": "8.8.0-alpha-b76ec274.0",
     "is-glob": "4.0.3",
     "micromatch": "^4.0.4",
     "tslib": "^2.4.0",
@@ -21,21 +21,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"
   }
-}
+}