@graphql-codegen/cli 3.3.2-rc-20230512163241-1dedabd22 → 3.3.2-rc-20230512164352-dd85e9e33

package/esm/utils/abort-controller-polyfill.js

@@ -0,0 +1,92 @@
+var _a, _b;
+import { EventEmitter } from 'events';
+import { debugLog } from './debugging.js';
+/**
+ * Node v14 does not have AbortSignal or AbortController, so to safely use it in
+ * another module, you can import it from here.
+ *
+ * Node v14.7+ does have it, but only with flag --experimental-abortcontroller
+ *
+ * We don't actually use AbortController anywhere except in tests, but it
+ * still gets called in watcher.ts, so by polyfilling it we can avoid breaking
+ * existing installations using Node v14 without flag --experimental-abortcontroller,
+ * and we also ensure that tests continue to pass under Node v14 without any new flags.
+ *
+ * This polyfill was adapted (TypeScript-ified) from here:
+ * https://github.com/southpolesteve/node-abort-controller/blob/master/index.js
+ */
+class AbortSignalPolyfill {
+    constructor() {
+        this.eventEmitter = new EventEmitter();
+        this.onabort = null;
+        this.aborted = false;
+        this.reason = undefined;
+    }
+    toString() {
+        return '[object AbortSignal]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortSignal';
+    }
+    removeEventListener(name, handler) {
+        this.eventEmitter.removeListener(name, handler);
+    }
+    addEventListener(name, handler) {
+        this.eventEmitter.on(name, handler);
+    }
+    // @ts-expect-error No Event type in Node 14
+    dispatchEvent(type) {
+        const event = { type, target: this };
+        const handlerName = `on${event.type}`;
+        if (typeof this[handlerName] === 'function')
+            this[handlerName](event);
+        return this.eventEmitter.emit(event.type, event);
+    }
+    throwIfAborted() {
+        if (this.aborted) {
+            throw this.reason;
+        }
+    }
+    static abort(reason) {
+        const controller = new AbortController();
+        controller.abort(reason);
+        return controller.signal;
+    }
+    static timeout(time) {
+        const controller = new AbortController();
+        setTimeout(() => controller.abort(new Error('TimeoutError')), time);
+        return controller.signal;
+    }
+}
+const AbortSignal = (_a = global.AbortSignal) !== null && _a !== void 0 ? _a : AbortSignalPolyfill;
+class AbortControllerPolyfill {
+    constructor() {
+        debugLog('Using polyfilled AbortController');
+        // @ts-expect-error No Event type in Node 14
+        this.signal = new AbortSignal();
+    }
+    abort(reason) {
+        if (this.signal.aborted)
+            return;
+        // @ts-expect-error Not a read only property when polyfilling
+        this.signal.aborted = true;
+        if (reason) {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = reason;
+        }
+        else {
+            // @ts-expect-error Not a read only property when polyfilling
+            this.signal.reason = new Error('AbortError');
+        }
+        // @ts-expect-error No Event type in Node 14
+        this.signal.dispatchEvent('abort');
+    }
+    toString() {
+        return '[object AbortController]';
+    }
+    get [Symbol.toStringTag]() {
+        return 'AbortController';
+    }
+}
+const AbortController = (_b = global.AbortController) !== null && _b !== void 0 ? _b : AbortControllerPolyfill;
+export { AbortController };

package/esm/utils/file-system.js

@@ -1,5 +1,8 @@
 import { promises, unlink as fsUnlink } from 'fs';
-const { writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = promises;
+const { access: fsAccess, writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = promises;
+export function access(...args) {
+    return fsAccess(...args);
+}
 export function writeFile(filepath, content) {
     return fsWriteFile(filepath, content);
 }

package/esm/utils/patterns.js

@@ -0,0 +1,226 @@
+import { isAbsolute, relative } from 'path';
+import { isValidPath } from '@graphql-tools/utils';
+import { normalizeInstanceOrArray } from '@graphql-codegen/plugin-helpers';
+import isGlob from 'is-glob';
+import mm from 'micromatch';
+/**
+ * Flatten a list of pattern sets to be a list of only the affirmative patterns
+ * are contained in all of them.
+ *
+ * This can be used, for example, to find the "longest common prefix directory"
+ * by examining `mm.scan(pattern).base` for each `pattern`.
+ */
+export const allAffirmativePatternsFromPatternSets = (patternSets) => {
+    return patternSets.flatMap(patternSet => [
+        ...patternSet.watch.affirmative,
+        ...patternSet.documents.affirmative,
+        ...patternSet.schemas.affirmative,
+    ]);
+};
+/**
+ * Create a rebuild trigger that follows the algorithm described here:
+ * https://github.com/dotansimha/graphql-code-generator/issues/9270#issuecomment-1496765045
+ *
+ * There is a flow chart diagram in that comment.
+ *
+ * Basically:
+ *
+ *  * "Global" patterns are defined at top level of config file, and "local"
+ *    patterns are defined for each output target
+ *  * Each pattern can have "watch", "documents", and "schemas"
+ *  * Watch patterns (global and local) always take precedence over documents and
+ *    schemas patterns, i.e. a watch negation always negates, and a watch match is
+ *    a match even if it would be negated by some pattern in documents or schemas
+ *  * The trigger returns true if any output target's local patterns result in
+ *    a match, after considering the precedence of any global and local negations
+ */
+export const makeShouldRebuild = ({ globalPatternSet, localPatternSets, }) => {
+    const localMatchers = localPatternSets.map(localPatternSet => {
+        return (path) => {
+            // Is path negated by any negating watch pattern?
+            if (matchesAnyNegatedPattern(path, [...globalPatternSet.watch.negated, ...localPatternSet.watch.negated])) {
+                // Short circut: negations in watch patterns take priority
+                return false;
+            }
+            // Does path match any affirmative watch pattern?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.watch.affirmative,
+                ...localPatternSet.watch.affirmative,
+            ])) {
+                // Immediately return true: Watch pattern takes priority, even if documents or schema would negate it
+                return true;
+            }
+            // Does path match documents patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.documents.affirmative,
+                ...localPatternSet.documents.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.documents.negated, ...localPatternSet.documents.negated])) {
+                return true;
+            }
+            // Does path match schemas patterns (without being negated)?
+            if (matchesAnyAffirmativePattern(path, [
+                ...globalPatternSet.schemas.affirmative,
+                ...localPatternSet.schemas.affirmative,
+            ]) &&
+                !matchesAnyNegatedPattern(path, [...globalPatternSet.schemas.negated, ...localPatternSet.schemas.negated])) {
+                return true;
+            }
+            // Otherwise, there is no match
+            return false;
+        };
+    });
+    /**
+     * Return `true` if `path` should trigger a rebuild
+     */
+    return ({ path: absolutePath }) => {
+        if (!isAbsolute(absolutePath)) {
+            throw new Error('shouldRebuild trigger should be called with absolute path');
+        }
+        const path = relative(process.cwd(), absolutePath);
+        const shouldRebuild = localMatchers.some(matcher => matcher(path));
+        return shouldRebuild;
+    };
+};
+/**
+ * Create the pattern set for the "global" (top level) config.
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over local configs, and any schemas and documents patterns will be
+ * mixed into the pattern set of each local config.
+ */
+export const makeGlobalPatternSet = (initialContext) => {
+    var _a;
+    const config = initialContext.getConfig();
+    return {
+        watch: sortPatterns([
+            ...(typeof config.watch === 'boolean' ? [] : normalizeInstanceOrArray((_a = config.watch) !== null && _a !== void 0 ? _a : [])),
+            relative(process.cwd(), initialContext.filepath),
+        ]),
+        schemas: sortPatterns(makePatternsFromSchemas(normalizeInstanceOrArray(config.schema))),
+        documents: sortPatterns(makePatternsFromDocuments(normalizeInstanceOrArray(config.documents))),
+    };
+};
+/**
+ * Create the pattern set for a "local" (output target) config
+ *
+ * In the `shouldRebuild` algorithm, any of these watch patterns will take
+ * precedence over documents or schemas patterns, and the documents and schemas
+ * patterns will be mixed into the pattern set of their respective gobal pattern
+ * set equivalents.
+ */
+export const makeLocalPatternSet = (conf) => {
+    return {
+        watch: sortPatterns(normalizeInstanceOrArray(conf.watchPattern)),
+        documents: sortPatterns(makePatternsFromDocuments(normalizeInstanceOrArray(conf.documents))),
+        schemas: sortPatterns(makePatternsFromSchemas(normalizeInstanceOrArray(conf.schema))),
+    };
+};
+/**
+ * Parse a list of micromatch patterns from a list of documents, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromDocuments = (documents) => {
+    const patterns = [];
+    if (documents) {
+        for (const doc of documents) {
+            if (typeof doc === 'string') {
+                patterns.push(doc);
+            }
+            else {
+                patterns.push(...Object.keys(doc));
+            }
+        }
+    }
+    return patterns;
+};
+/**
+ * Parse a list of micromatch patterns from a list of schemas, which should
+ * already have been normalized from their raw config values.
+ */
+const makePatternsFromSchemas = (schemas) => {
+    const patterns = [];
+    for (const s of schemas) {
+        const schema = s;
+        if (isGlob(schema) || isValidPath(schema)) {
+            patterns.push(schema);
+        }
+    }
+    return patterns;
+};
+/**
+ * Given a list of micromatch patterns, sort them into `patterns` (all of them),
+ * `affirmative` (only the affirmative patterns), and `negated` (only the negated patterns)
+ *
+ * @param patterns List of micromatch patterns
+ */
+export const sortPatterns = (patterns) => ({
+    patterns,
+    affirmative: onlyAffirmativePatterns(patterns),
+    negated: onlyNegatedPatterns(patterns),
+});
+/**
+ * Filter the provided list of patterns to include only "affirmative" (non-negated) patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyAffirmativePatterns = (patterns) => {
+    return patterns.filter(pattern => !mm.scan(pattern).negated);
+};
+/**
+ * Filter the provided list of patterns to include only negated patterns.
+ *
+ * @param patterns List of micromatch patterns (or paths) to filter
+ */
+const onlyNegatedPatterns = (patterns) => {
+    return patterns.filter(pattern => mm.scan(pattern).negated);
+};
+/**
+ * Given a list of negated patterns, invert them by removing their negation prefix
+ *
+ * If there is a non-negated pattern in the list, throw an error, because this
+ * function should only be called after filtering the list to be only negated patterns
+ *
+ * @param patterns List of negated micromatch patterns
+ */
+const invertNegatedPatterns = (patterns) => {
+    return patterns.map(pattern => {
+        const scanned = mm.scan(pattern);
+        if (!scanned.negated) {
+            throw new Error(`onlyNegatedPatterns got a non-negated pattern: ${pattern}`);
+        }
+        // Remove the leading prefix (NOTE: this is not always "!")
+        // e.g. mm.scan("!./foo/bar/never-watch.graphql").prefix === '!./'
+        return pattern.slice(scanned.prefix.length);
+    });
+};
+/**
+ * Return true if relativeCandidatePath matches any of the affirmativePatterns
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the supplied affirmativePatterns
+ * @param affirmativePatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyAffirmativePattern = (relativeCandidatePath, affirmativePatterns) => {
+    if (isAbsolute(relativeCandidatePath)) {
+        throw new Error('matchesAny should only be called with relative candidate path');
+    }
+    // Developer error: This function is not intended to work with pattern sets including negations
+    if (affirmativePatterns.some(pattern => mm.scan(pattern).negated)) {
+        throw new Error('matchesAnyAffirmativePattern should only include affirmative patterns');
+    }
+    // micromatch.isMatch does not omit matches that are negated by negation patterns,
+    // which is why we require this function only examine affirmative patterns
+    return mm.isMatch(relativeCandidatePath, affirmativePatterns);
+};
+/**
+ * Return true if relativeCandidatePath matches any of the negatedPatterns
+ *
+ * This function will invert the negated patterns and then call matchesAnyAffirmativePattern
+ *
+ * @param relativeCandidatePath A relative path to evaluate against the suppliednegatedPatterns
+ * @param negatedPatterns A list of patterns, containing no negated patterns, to evaluate
+ */
+const matchesAnyNegatedPattern = (relativeCandidatePath, negatedPatterns) => {
+    // NOTE: No safety check that negatedPatterns contains only negated, because that will happen in invertedNegatedPatterns
+    return matchesAnyAffirmativePattern(relativeCandidatePath, invertNegatedPatterns(negatedPatterns));
+};

package/esm/utils/watcher.js

@@ -1,16 +1,16 @@
-import { access } from 'node:fs/promises';
-import { join, isAbsolute, resolve, sep } from 'path';
-import { normalizeInstanceOrArray, normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
-import { isValidPath } from '@graphql-tools/utils';
+import { join, isAbsolute, relative, resolve, sep } from 'path';
+import { normalizeOutputParam } from '@graphql-codegen/plugin-helpers';
 import debounce from 'debounce';
-import isGlob from 'is-glob';
 import mm from 'micromatch';
 import logSymbols from 'log-symbols';
 import { executeCodegen } from '../codegen.js';
 import { loadContext } from '../config.js';
 import { lifecycleHooks } from '../hooks.js';
+import { access } from './file-system.js';
 import { debugLog } from './debugging.js';
 import { getLogger } from './logger.js';
+import { allAffirmativePatternsFromPatternSets, makeGlobalPatternSet, makeLocalPatternSet, makeShouldRebuild, } from './patterns.js';
+import { AbortController } from './abort-controller-polyfill.js';
 function log(msg) {
     // double spaces to inline the message with Listr
     getLogger().info(`  ${msg}`);
@@ -18,47 +18,25 @@ function log(msg) {
 function emitWatching(watchDir) {
     log(`${logSymbols.info} Watching for changes in ${watchDir}...`);
 }
-export const createWatcher = (initalContext, onNext) => {
+export const createWatcher = (initialContext, onNext) => {
     debugLog(`[Watcher] Starting watcher...`);
-    let config = initalContext.getConfig();
-    const files = [initalContext.filepath].filter(a => a);
-    const documents = normalizeInstanceOrArray(config.documents);
-    const schemas = normalizeInstanceOrArray(config.schema);
-    // Add schemas and documents from "generates"
-    for (const conf of Object.keys(config.generates).map(filename => normalizeOutputParam(config.generates[filename]))) {
-        schemas.push(...normalizeInstanceOrArray(conf.schema));
-        documents.push(...normalizeInstanceOrArray(conf.documents));
-        files.push(...normalizeInstanceOrArray(conf.watchPattern));
-    }
-    if (documents) {
-        for (const doc of documents) {
-            if (typeof doc === 'string') {
-                files.push(doc);
-            }
-            else {
-                files.push(...Object.keys(doc));
-            }
-        }
-    }
-    for (const s of schemas) {
-        const schema = s;
-        if (isGlob(schema) || isValidPath(schema)) {
-            files.push(schema);
-        }
-    }
-    if (typeof config.watch !== 'boolean') {
-        files.push(...normalizeInstanceOrArray(config.watch));
-    }
+    let config = initialContext.getConfig();
+    const globalPatternSet = makeGlobalPatternSet(initialContext);
+    const localPatternSets = Object.keys(config.generates)
+        .map(filename => normalizeOutputParam(config.generates[filename]))
+        .map(conf => makeLocalPatternSet(conf));
+    const allAffirmativePatterns = allAffirmativePatternsFromPatternSets([globalPatternSet, ...localPatternSets]);
+    const shouldRebuild = makeShouldRebuild({ globalPatternSet, localPatternSets });
     let watcherSubscription;
-    const runWatcher = async () => {
+    const runWatcher = async (abortSignal) => {
         var _a;
-        const watchDirectory = await findHighestCommonDirectory(files);
+        const watchDirectory = await findHighestCommonDirectory(allAffirmativePatterns);
         const parcelWatcher = await import('@parcel/watcher');
         debugLog(`[Watcher] Parcel watcher loaded...`);
         let isShutdown = false;
         const debouncedExec = debounce(() => {
             if (!isShutdown) {
-                executeCodegen(initalContext)
+                executeCodegen(initialContext)
                     .then(onNext, () => Promise.resolve())
                     .then(() => emitWatching(watchDirectory));
             }
@@ -69,34 +47,35 @@ export const createWatcher = (initalContext, onNext) => {
             filename,
             config: normalizeOutputParam(config.generates[filename]),
         }))) {
+            // ParcelWatcher expects relative ignore patterns to be relative from watchDirectory,
+            // but we expect filename from config to be relative from cwd, so we need to convert
+            const filenameRelativeFromWatchDirectory = relative(watchDirectory, resolve(process.cwd(), entry.filename));
             if (entry.config.preset) {
                 const extension = (_a = entry.config.presetConfig) === null || _a === void 0 ? void 0 : _a.extension;
                 if (extension) {
-                    ignored.push(join(entry.filename, '**', '*' + extension));
+                    ignored.push(join(filenameRelativeFromWatchDirectory, '**', '*' + extension));
                 }
             }
             else {
-                ignored.push(entry.filename);
+                ignored.push(filenameRelativeFromWatchDirectory);
             }
         }
         watcherSubscription = await parcelWatcher.subscribe(watchDirectory, async (_, events) => {
             // it doesn't matter what has changed, need to run whole process anyway
-            await Promise.all(events.map(async ({ type: eventName, path }) => {
-                /**
-                 * @parcel/watcher has no way to run watcher on specific files (https://github.com/parcel-bundler/watcher/issues/42)
-                 * But we can use micromatch to filter out events that we don't care about
-                 */
-                if (!mm.contains(path, files))
+            await Promise.all(
+            // NOTE: @parcel/watcher always provides path as an absolute path
+            events.map(async ({ type: eventName, path }) => {
+                if (!shouldRebuild({ path })) {
                     return;
+                }
                 lifecycleHooks(config.hooks).onWatchTriggered(eventName, path);
                 debugLog(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
-                const fullPath = join(watchDirectory, path);
                 // In ESM require is not defined
                 try {
-                    delete require.cache[fullPath];
+                    delete require.cache[path];
                 }
                 catch (err) { }
-                if (eventName === 'update' && config.configFilePath && fullPath === config.configFilePath) {
+                if (eventName === 'update' && config.configFilePath && path === config.configFilePath) {
                     log(`${logSymbols.info} Config file has changed, reloading...`);
                     const context = await loadContext(config.configFilePath);
                     const newParsedConfig = context.getConfig();
@@ -105,35 +84,76 @@ export const createWatcher = (initalContext, onNext) => {
                     newParsedConfig.overwrite = config.overwrite;
                     newParsedConfig.configFilePath = config.configFilePath;
                     config = newParsedConfig;
-                    initalContext.updateConfig(config);
+                    initialContext.updateConfig(config);
                 }
                 debouncedExec();
             }));
         }, { ignore: ignored });
         debugLog(`[Watcher] Started`);
-        const shutdown = () => {
+        const shutdown = (
+        /** Optional callback to execute after shutdown has completed its async tasks */
+        afterShutdown) => {
             isShutdown = true;
             debugLog(`[Watcher] Shutting down`);
             log(`Shutting down watch...`);
-            watcherSubscription.unsubscribe();
-            lifecycleHooks(config.hooks).beforeDone();
+            const pendingUnsubscribe = watcherSubscription.unsubscribe();
+            const pendingBeforeDoneHook = lifecycleHooks(config.hooks).beforeDone();
+            if (afterShutdown && typeof afterShutdown === 'function') {
+                Promise.allSettled([pendingUnsubscribe, pendingBeforeDoneHook]).then(afterShutdown);
+            }
         };
-        process.once('SIGINT', shutdown);
-        process.once('SIGTERM', shutdown);
+        abortSignal.addEventListener('abort', () => shutdown(abortSignal.reason));
+        process.once('SIGINT', () => shutdown());
+        process.once('SIGTERM', () => shutdown());
     };
-    // the promise never resolves to keep process running
-    return new Promise((resolve, reject) => {
-        executeCodegen(initalContext)
+    // Use an AbortController for shutdown signals
+    // NOTE: This will be polyfilled on Node 14 (or any environment without it defined)
+    const abortController = new AbortController();
+    /**
+     * Send shutdown signal and return a promise that only resolves after the
+     * runningWatcher has resolved, which only resolved after the shutdown signal has been handled
+     */
+    const stopWatching = async function () {
+        // stopWatching.afterShutdown is lazily set to resolve pendingShutdown promise
+        abortController.abort(stopWatching.afterShutdown);
+        // SUBTLE: runningWatcher waits for pendingShutdown before it resolves itself, so
+        // by awaiting it here, we are awaiting both the shutdown handler, and runningWatcher itself
+        await stopWatching.runningWatcher;
+    };
+    stopWatching.afterShutdown = () => {
+        debugLog('Shutdown watcher before it started');
+    };
+    stopWatching.runningWatcher = Promise.resolve();
+    /** Promise will resolve after the shutdown() handler completes */
+    const pendingShutdown = new Promise(afterShutdown => {
+        // afterShutdown will be passed to shutdown() handler via abortSignal.reason
+        stopWatching.afterShutdown = afterShutdown;
+    });
+    /**
+     * Promise that resolves after the watch server has shutdown, either because
+     * stopWatching() was called or there was an error inside it
+     */
+    stopWatching.runningWatcher = new Promise((resolve, reject) => {
+        executeCodegen(initialContext)
             .then(onNext, () => Promise.resolve())
-            .then(runWatcher)
+            .then(() => runWatcher(abortController.signal))
             .catch(err => {
             watcherSubscription.unsubscribe();
             reject(err);
+        })
+            .then(() => pendingShutdown)
+            .finally(() => {
+            debugLog('Done watching.');
+            resolve();
         });
     });
+    return {
+        stopWatching,
+        runningWatcher: stopWatching.runningWatcher,
+    };
 };
 /**
- * Given a list of file paths (each of which may be absolute, or relative to
+ * Given a list of file paths (each of which may be absolute, or relative from
  * `process.cwd()`), find absolute path of the "highest" common directory,
  * i.e. the directory that contains all the files in the list.
  *

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@graphql-codegen/cli",
-  "version": "3.3.2-rc-20230512163241-1dedabd22",
+  "version": "3.3.2-rc-20230512164352-dd85e9e33",
   "peerDependencies": {
     "graphql": "^0.8.0 || ^0.9.0 || ^0.10.0 || ^0.11.0 || ^0.12.0 || ^0.13.0 || ^14.0.0 || ^15.0.0 || ^16.0.0"
   },
@@ -9,7 +9,7 @@
     "@babel/template": "^7.18.10",
     "@babel/types": "^7.18.13",
     "@graphql-codegen/core": "^3.1.0",
-    "@graphql-codegen/plugin-helpers": "4.2.1-rc-20230512163241-1dedabd22",
+    "@graphql-codegen/plugin-helpers": "4.2.1-rc-20230512164352-dd85e9e33",
     "@graphql-tools/apollo-engine-loader": "^7.3.6",
     "@graphql-tools/code-file-loader": "^7.3.17",
     "@graphql-tools/git-loader": "^7.2.13",

package/typings/utils/abort-controller-polyfill.d.cts

@@ -0,0 +1,5 @@
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+export { AbortController };

package/typings/utils/abort-controller-polyfill.d.ts

@@ -0,0 +1,5 @@
+declare const AbortController: {
+    new (): AbortController;
+    prototype: AbortController;
+};
+export { AbortController };

package/typings/utils/file-system.d.cts

@@ -1,4 +1,9 @@
+/// <reference types="node" />
+import { promises } from 'fs';
+declare const fsAccess: typeof promises.access;
+export declare function access(...args: Parameters<typeof fsAccess>): Promise<void>;
 export declare function writeFile(filepath: string, content: string): Promise<void>;
 export declare function readFile(filepath: string): Promise<string>;
 export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;
 export declare function mkdirp(filePath: string): Promise<string>;
+export {};

package/typings/utils/file-system.d.ts

@@ -1,4 +1,9 @@
+/// <reference types="node" />
+import { promises } from 'fs';
+declare const fsAccess: typeof promises.access;
+export declare function access(...args: Parameters<typeof fsAccess>): Promise<void>;
 export declare function writeFile(filepath: string, content: string): Promise<void>;
 export declare function readFile(filepath: string): Promise<string>;
 export declare function unlinkFile(filePath: string, cb?: (err?: Error) => any): void;
 export declare function mkdirp(filePath: string): Promise<string>;
+export {};