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

package/cjs/generate-and-save.js

@@ -97,7 +97,7 @@ async function generate(input, saveToFile = true) {
     }
     // watch mode
     if (config.watch) {
-        return (0, watcher_js_1.createWatcher)(context, writeOutput);
+        return (0, watcher_js_1.createWatcher)(context, writeOutput).runningWatcher;
     }
     const outputFiles = await context.profiler.run(() => (0, codegen_js_1.executeCodegen)(context), 'executeCodegen');
     await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');

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

@@ -0,0 +1,95 @@
+"use strict";
+var _a, _b;
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.AbortController = void 0;
+const events_1 = require("events");
+const debugging_js_1 = require("./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 events_1.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() {
+        (0, debugging_js_1.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;
+exports.AbortController = AbortController;

package/cjs/utils/file-system.js

@@ -1,8 +1,12 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.mkdirp = exports.unlinkFile = exports.readFile = exports.writeFile = void 0;
+exports.mkdirp = exports.unlinkFile = exports.readFile = exports.writeFile = exports.access = void 0;
 const fs_1 = require("fs");
-const { writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = fs_1.promises;
+const { access: fsAccess, writeFile: fsWriteFile, readFile: fsReadFile, mkdir } = fs_1.promises;
+function access(...args) {
+    return fsAccess(...args);
+}
+exports.access = access;
 function writeFile(filepath, content) {
     return fsWriteFile(filepath, content);
 }

package/cjs/utils/patterns.js

@@ -0,0 +1,235 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sortPatterns = exports.makeLocalPatternSet = exports.makeGlobalPatternSet = exports.makeShouldRebuild = exports.allAffirmativePatternsFromPatternSets = void 0;
+const tslib_1 = require("tslib");
+const path_1 = require("path");
+const utils_1 = require("@graphql-tools/utils");
+const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
+const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
+const micromatch_1 = tslib_1.__importDefault(require("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`.
+ */
+const allAffirmativePatternsFromPatternSets = (patternSets) => {
+    return patternSets.flatMap(patternSet => [
+        ...patternSet.watch.affirmative,
+        ...patternSet.documents.affirmative,
+        ...patternSet.schemas.affirmative,
+    ]);
+};
+exports.allAffirmativePatternsFromPatternSets = allAffirmativePatternsFromPatternSets;
+/**
+ * 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
+ */
+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 (!(0, path_1.isAbsolute)(absolutePath)) {
+            throw new Error('shouldRebuild trigger should be called with absolute path');
+        }
+        const path = (0, path_1.relative)(process.cwd(), absolutePath);
+        const shouldRebuild = localMatchers.some(matcher => matcher(path));
+        return shouldRebuild;
+    };
+};
+exports.makeShouldRebuild = makeShouldRebuild;
+/**
+ * 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.
+ */
+const makeGlobalPatternSet = (initialContext) => {
+    var _a;
+    const config = initialContext.getConfig();
+    return {
+        watch: (0, exports.sortPatterns)([
+            ...(typeof config.watch === 'boolean' ? [] : (0, plugin_helpers_1.normalizeInstanceOrArray)((_a = config.watch) !== null && _a !== void 0 ? _a : [])),
+            (0, path_1.relative)(process.cwd(), initialContext.filepath),
+        ]),
+        schemas: (0, exports.sortPatterns)(makePatternsFromSchemas((0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema))),
+        documents: (0, exports.sortPatterns)(makePatternsFromDocuments((0, plugin_helpers_1.normalizeInstanceOrArray)(config.documents))),
+    };
+};
+exports.makeGlobalPatternSet = makeGlobalPatternSet;
+/**
+ * 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.
+ */
+const makeLocalPatternSet = (conf) => {
+    return {
+        watch: (0, exports.sortPatterns)((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.watchPattern)),
+        documents: (0, exports.sortPatterns)(makePatternsFromDocuments((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.documents))),
+        schemas: (0, exports.sortPatterns)(makePatternsFromSchemas((0, plugin_helpers_1.normalizeInstanceOrArray)(conf.schema))),
+    };
+};
+exports.makeLocalPatternSet = makeLocalPatternSet;
+/**
+ * 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 ((0, is_glob_1.default)(schema) || (0, utils_1.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
+ */
+const sortPatterns = (patterns) => ({
+    patterns,
+    affirmative: onlyAffirmativePatterns(patterns),
+    negated: onlyNegatedPatterns(patterns),
+});
+exports.sortPatterns = sortPatterns;
+/**
+ * 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 => !micromatch_1.default.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 => micromatch_1.default.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 = micromatch_1.default.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 ((0, path_1.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 => micromatch_1.default.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 micromatch_1.default.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/cjs/utils/watcher.js

@@ -2,19 +2,19 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.createWatcher = void 0;
 const tslib_1 = require("tslib");
-const promises_1 = require("node:fs/promises");
 const path_1 = require("path");
 const plugin_helpers_1 = require("@graphql-codegen/plugin-helpers");
-const utils_1 = require("@graphql-tools/utils");
 const debounce_1 = tslib_1.__importDefault(require("debounce"));
-const is_glob_1 = tslib_1.__importDefault(require("is-glob"));
 const micromatch_1 = tslib_1.__importDefault(require("micromatch"));
 const log_symbols_1 = tslib_1.__importDefault(require("log-symbols"));
 const codegen_js_1 = require("../codegen.js");
 const config_js_1 = require("../config.js");
 const hooks_js_1 = require("../hooks.js");
+const file_system_js_1 = require("./file-system.js");
 const debugging_js_1 = require("./debugging.js");
 const logger_js_1 = require("./logger.js");
+const patterns_js_1 = require("./patterns.js");
+const abort_controller_polyfill_js_1 = require("./abort-controller-polyfill.js");
 function log(msg) {
     // double spaces to inline the message with Listr
     (0, logger_js_1.getLogger)().info(`  ${msg}`);
@@ -22,47 +22,25 @@ function log(msg) {
 function emitWatching(watchDir) {
     log(`${log_symbols_1.default.info} Watching for changes in ${watchDir}...`);
 }
-const createWatcher = (initalContext, onNext) => {
+const createWatcher = (initialContext, onNext) => {
     (0, debugging_js_1.debugLog)(`[Watcher] Starting watcher...`);
-    let config = initalContext.getConfig();
-    const files = [initalContext.filepath].filter(a => a);
-    const documents = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.documents);
-    const schemas = (0, plugin_helpers_1.normalizeInstanceOrArray)(config.schema);
-    // Add schemas and documents from "generates"
-    for (const conf of Object.keys(config.generates).map(filename => (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]))) {
-        schemas.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(conf.schema));
-        documents.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(conf.documents));
-        files.push(...(0, plugin_helpers_1.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 ((0, is_glob_1.default)(schema) || (0, utils_1.isValidPath)(schema)) {
-            files.push(schema);
-        }
-    }
-    if (typeof config.watch !== 'boolean') {
-        files.push(...(0, plugin_helpers_1.normalizeInstanceOrArray)(config.watch));
-    }
+    let config = initialContext.getConfig();
+    const globalPatternSet = (0, patterns_js_1.makeGlobalPatternSet)(initialContext);
+    const localPatternSets = Object.keys(config.generates)
+        .map(filename => (0, plugin_helpers_1.normalizeOutputParam)(config.generates[filename]))
+        .map(conf => (0, patterns_js_1.makeLocalPatternSet)(conf));
+    const allAffirmativePatterns = (0, patterns_js_1.allAffirmativePatternsFromPatternSets)([globalPatternSet, ...localPatternSets]);
+    const shouldRebuild = (0, patterns_js_1.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 Promise.resolve().then(() => tslib_1.__importStar(require('@parcel/watcher')));
         (0, debugging_js_1.debugLog)(`[Watcher] Parcel watcher loaded...`);
         let isShutdown = false;
         const debouncedExec = (0, debounce_1.default)(() => {
             if (!isShutdown) {
-                (0, codegen_js_1.executeCodegen)(initalContext)
+                (0, codegen_js_1.executeCodegen)(initialContext)
                     .then(onNext, () => Promise.resolve())
                     .then(() => emitWatching(watchDirectory));
             }
@@ -73,34 +51,35 @@ const createWatcher = (initalContext, onNext) => {
             filename,
             config: (0, plugin_helpers_1.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 = (0, path_1.relative)(watchDirectory, (0, path_1.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((0, path_1.join)(entry.filename, '**', '*' + extension));
+                    ignored.push((0, path_1.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 (!micromatch_1.default.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;
+                }
                 (0, hooks_js_1.lifecycleHooks)(config.hooks).onWatchTriggered(eventName, path);
                 (0, debugging_js_1.debugLog)(`[Watcher] triggered due to a file ${eventName} event: ${path}`);
-                const fullPath = (0, path_1.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(`${log_symbols_1.default.info} Config file has changed, reloading...`);
                     const context = await (0, config_js_1.loadContext)(config.configFilePath);
                     const newParsedConfig = context.getConfig();
@@ -109,36 +88,77 @@ const createWatcher = (initalContext, onNext) => {
                     newParsedConfig.overwrite = config.overwrite;
                     newParsedConfig.configFilePath = config.configFilePath;
                     config = newParsedConfig;
-                    initalContext.updateConfig(config);
+                    initialContext.updateConfig(config);
                 }
                 debouncedExec();
             }));
         }, { ignore: ignored });
         (0, debugging_js_1.debugLog)(`[Watcher] Started`);
-        const shutdown = () => {
+        const shutdown = (
+        /** Optional callback to execute after shutdown has completed its async tasks */
+        afterShutdown) => {
             isShutdown = true;
             (0, debugging_js_1.debugLog)(`[Watcher] Shutting down`);
             log(`Shutting down watch...`);
-            watcherSubscription.unsubscribe();
-            (0, hooks_js_1.lifecycleHooks)(config.hooks).beforeDone();
+            const pendingUnsubscribe = watcherSubscription.unsubscribe();
+            const pendingBeforeDoneHook = (0, hooks_js_1.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) => {
-        (0, codegen_js_1.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 abort_controller_polyfill_js_1.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 = () => {
+        (0, debugging_js_1.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) => {
+        (0, codegen_js_1.executeCodegen)(initialContext)
             .then(onNext, () => Promise.resolve())
-            .then(runWatcher)
+            .then(() => runWatcher(abortController.signal))
             .catch(err => {
             watcherSubscription.unsubscribe();
             reject(err);
+        })
+            .then(() => pendingShutdown)
+            .finally(() => {
+            (0, debugging_js_1.debugLog)('Done watching.');
+            resolve();
         });
     });
+    return {
+        stopWatching,
+        runningWatcher: stopWatching.runningWatcher,
+    };
 };
 exports.createWatcher = createWatcher;
 /**
- * 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.
  *
@@ -154,7 +174,7 @@ const findHighestCommonDirectory = async (files) => {
     return (async (maybeValidPath) => {
         (0, debugging_js_1.debugLog)(`[Watcher] Longest common prefix of all files: ${maybeValidPath}...`);
         try {
-            await (0, promises_1.access)(maybeValidPath);
+            await (0, file_system_js_1.access)(maybeValidPath);
             return maybeValidPath;
         }
         catch (_a) {

package/esm/generate-and-save.js

@@ -94,7 +94,7 @@ export async function generate(input, saveToFile = true) {
     }
     // watch mode
     if (config.watch) {
-        return createWatcher(context, writeOutput);
+        return createWatcher(context, writeOutput).runningWatcher;
     }
     const outputFiles = await context.profiler.run(() => executeCodegen(context), 'executeCodegen');
     await context.profiler.run(() => writeOutput(outputFiles), 'writeOutput');