nx 19.6.0-beta.1 → 19.6.0-beta.3

package/src/command-line/release/plan-check.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.releasePlanCheckCLIHandler = void 0;
+exports.createAPI = createAPI;
+const nx_json_1 = require("../../config/nx-json");
+const workspace_projects_1 = require("../../project-graph/affected/locators/workspace-projects");
+const file_map_utils_1 = require("../../project-graph/file-map-utils");
+const file_utils_1 = require("../../project-graph/file-utils");
+const project_graph_1 = require("../../project-graph/project-graph");
+const all_file_data_1 = require("../../utils/all-file-data");
+const command_line_utils_1 = require("../../utils/command-line-utils");
+const ignore_1 = require("../../utils/ignore");
+const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
+const config_1 = require("./config/config");
+const deep_merge_json_1 = require("./config/deep-merge-json");
+const filter_release_groups_1 = require("./config/filter-release-groups");
+const version_plans_1 = require("./config/version-plans");
+const print_config_1 = require("./utils/print-config");
+const releasePlanCheckCLIHandler = (args) => (0, params_1.handleErrors)(args.verbose, () => createAPI({})(args));
+exports.releasePlanCheckCLIHandler = releasePlanCheckCLIHandler;
+function createAPI(overrideReleaseConfig) {
+    return async function releasePlanCheck(args) {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)({ exitOnError: true });
+        const nxJson = (0, nx_json_1.readNxJson)();
+        const userProvidedReleaseConfig = (0, deep_merge_json_1.deepMergeJson)(nxJson.release ?? {}, overrideReleaseConfig ?? {});
+        if (args.verbose) {
+            process.env.NX_VERBOSE_LOGGING = 'true';
+        }
+        // Apply default configuration to any optional user configuration
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
+        if (configError) {
+            return await (0, config_1.handleNxReleaseConfigError)(configError);
+        }
+        // --print-config exits directly as it is not designed to be combined with any other programmatic operations
+        if (args.printConfig) {
+            return (0, print_config_1.printConfigAndExit)({
+                userProvidedReleaseConfig,
+                nxReleaseConfig,
+                isDebug: args.printConfig === 'debug',
+            });
+        }
+        const { error: filterError, releaseGroups, releaseGroupToFilteredProjects, } = (0, filter_release_groups_1.filterReleaseGroups)(projectGraph, nxReleaseConfig, args.projects, args.groups);
+        if (filterError) {
+            output_1.output.error(filterError);
+            process.exit(1);
+        }
+        // If no release groups have version plans enabled, provide an explicit error
+        if (!releaseGroups.some((group) => group.versionPlans)) {
+            output_1.output.error({
+                title: 'Version plans are not enabled',
+                bodyLines: [
+                    'Please ensure at least one release group has version plans enabled in your Nx release configuration if you want to use this command.',
+                    // TODO: Add docs link here once it is available
+                ],
+            });
+            return 1;
+        }
+        const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        // Resolve the final values for base, head etc to use when resolving the changes to consider
+        const { nxArgs } = (0, command_line_utils_1.splitArgsIntoNxArgsAndOverrides)(args, 'affected', {
+            printWarnings: args.verbose,
+        }, nxJson);
+        const changedFiles = (0, command_line_utils_1.parseFiles)(nxArgs).files;
+        if (nxArgs.verbose) {
+            if (changedFiles.length) {
+                output_1.output.log({
+                    title: `Changed files based on resolved "base" (${nxArgs.base}) and "head" (${nxArgs.head ?? 'HEAD'})`,
+                    bodyLines: changedFiles.map((file) => `  - ${file}`),
+                });
+            }
+            else {
+                output_1.output.warn({
+                    title: 'No changed files found based on resolved "base" and "head"',
+                });
+            }
+        }
+        const resolvedAllFileData = await (0, all_file_data_1.allFileData)();
+        /**
+         * Create a minimal subset of touched projects based on the configured ignore patterns, we only need
+         * to recompute when the ignorePatternsForPlanCheck differs between release groups.
+         */
+        const serializedIgnorePatternsToTouchedProjects = new Map();
+        const NOTE_ABOUT_VERBOSE_LOGGING = 'Run with --verbose to see the full list of changed files used for the touched projects logic.';
+        let hasErrors = false;
+        for (const releaseGroup of releaseGroups) {
+            // The current release group doesn't leverage version plans
+            if (!releaseGroup.versionPlans) {
+                continue;
+            }
+            const resolvedVersionPlans = releaseGroup.resolvedVersionPlans || [];
+            // Check upfront if the release group as a whole is featured in any version plan files
+            const matchingVersionPlanFiles = resolvedVersionPlans.filter((plan) => 'groupVersionBump' in plan);
+            if (matchingVersionPlanFiles.length) {
+                output_1.output.log({
+                    title: `${releaseGroup.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? `There are`
+                        : `Release group "${releaseGroup.name}" has`} pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...matchingVersionPlanFiles.map((plan) => `  - "${plan.groupVersionBump}" in ${plan.fileName}`),
+                    ],
+                });
+                continue;
+            }
+            // Exclude patterns from .nxignore, .gitignore and explicit version plan config
+            let serializedIgnorePatterns = '[]';
+            const ignore = (0, ignore_1.getIgnoreObject)();
+            if (typeof releaseGroup.versionPlans !== 'boolean' &&
+                Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                releaseGroup.versionPlans.ignorePatternsForPlanCheck.length) {
+                output_1.output.note({
+                    title: `Applying configured ignore patterns to changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` for release group "${releaseGroup.name}"`
+                        : ''}`,
+                    bodyLines: [
+                        ...releaseGroup.versionPlans.ignorePatternsForPlanCheck.map((pattern) => `  - ${pattern}`),
+                    ],
+                });
+                ignore.add(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+                serializedIgnorePatterns = JSON.stringify(releaseGroup.versionPlans.ignorePatternsForPlanCheck);
+            }
+            let touchedProjects = {};
+            if (serializedIgnorePatternsToTouchedProjects.has(serializedIgnorePatterns)) {
+                touchedProjects = serializedIgnorePatternsToTouchedProjects.get(serializedIgnorePatterns);
+            }
+            else {
+                // We only care about directly touched projects, not implicitly affected ones etc
+                const touchedProjectsArr = await (0, workspace_projects_1.getTouchedProjects)((0, file_utils_1.calculateFileChanges)(changedFiles, resolvedAllFileData, nxArgs, undefined, ignore), projectGraph.nodes);
+                touchedProjects = touchedProjectsArr.reduce((acc, project) => ({ ...acc, [project]: true }), {});
+                serializedIgnorePatternsToTouchedProjects.set(serializedIgnorePatterns, touchedProjects);
+            }
+            const touchedProjectsUnderReleaseGroup = releaseGroup.projects.filter((project) => touchedProjects[project]);
+            if (touchedProjectsUnderReleaseGroup.length) {
+                output_1.output.log({
+                    title: `Touched projects based on changed files${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''}`,
+                    bodyLines: [
+                        ...touchedProjectsUnderReleaseGroup.map((project) => `  - ${project}`),
+                        '',
+                        'NOTE: You can adjust your "versionPlans.ignorePatternsForPlanCheck" config to stop certain files from resulting in projects being classed as touched for the purposes of this command.',
+                    ],
+                });
+            }
+            else {
+                output_1.output.log({
+                    title: `No touched projects found based on changed files${typeof releaseGroup.versionPlans !== 'boolean' &&
+                        Array.isArray(releaseGroup.versionPlans.ignorePatternsForPlanCheck) &&
+                        releaseGroup.versionPlans.ignorePatternsForPlanCheck.length
+                        ? ' combined with configured ignore patterns'
+                        : ''}${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''}`,
+                });
+            }
+            const projectsInResolvedVersionPlans = resolvedVersionPlans.reduce((acc, plan) => {
+                if ('projectVersionBumps' in plan) {
+                    for (const project in plan.projectVersionBumps) {
+                        acc[project] = acc[project] || [];
+                        acc[project].push({
+                            bump: plan.projectVersionBumps[project],
+                            fileName: plan.fileName,
+                        });
+                    }
+                }
+                return acc;
+            }, {});
+            // Ensure each touched project under this release group features in at least one version plan file
+            let touchedProjectsNotFoundInVersionPlans = [];
+            for (const touchedProject of touchedProjectsUnderReleaseGroup) {
+                if (!resolvedVersionPlans.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+                const matchingVersionPlanFileEntries = projectsInResolvedVersionPlans[touchedProject];
+                if (!matchingVersionPlanFileEntries?.length) {
+                    touchedProjectsNotFoundInVersionPlans.push(touchedProject);
+                    continue;
+                }
+            }
+            // Log any resolved pending bumps, regardless of whether the projects were directly touched or not
+            for (const [projectName, entries] of Object.entries(projectsInResolvedVersionPlans)) {
+                output_1.output.log({
+                    title: `Project "${projectName}" has pending bumps in version plan(s)`,
+                    bodyLines: [
+                        ...entries.map(({ bump, fileName }) => `  - "${bump}" in ${fileName}`),
+                    ],
+                });
+            }
+            if (touchedProjectsNotFoundInVersionPlans.length) {
+                const bodyLines = [
+                    `The following touched projects${releaseGroup.name !== config_1.IMPLICIT_DEFAULT_RELEASE_GROUP
+                        ? ` under release group "${releaseGroup.name}"`
+                        : ''} do not feature in any version plan files:`,
+                    ...touchedProjectsNotFoundInVersionPlans.map((project) => `  - ${project}`),
+                    '',
+                    'Please use `nx release plan` to generate missing version plans, or adjust your "versionPlans.ignorePatternsForPlanCheck" config stop certain files from affecting the projects for the purposes of this command.',
+                ];
+                if (!nxArgs.verbose) {
+                    bodyLines.push('', NOTE_ABOUT_VERBOSE_LOGGING);
+                }
+                output_1.output.error({
+                    title: 'Touched projects missing version plans',
+                    bodyLines,
+                });
+                // At least one project in one release group has an issue
+                hasErrors = true;
+            }
+        }
+        // Do not print success message if any projects are missing version plans
+        if (hasErrors) {
+            return 1;
+        }
+        const bodyLines = [];
+        if (!nxArgs.verbose) {
+            bodyLines.push(NOTE_ABOUT_VERBOSE_LOGGING);
+        }
+        output_1.output.success({
+            title: 'All touched projects have, or do not require, version plans.',
+            bodyLines,
+        });
+        return 0;
+    };
+}

package/src/command-line/release/plan.js

@@ -31,7 +31,7 @@ function createAPI(overrideReleaseConfig) {
             process.env.NX_VERBOSE_LOGGING = 'true';
         }
         // Apply default configuration to any optional user configuration
-        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), nxJson.release);
+        const { error: configError, nxReleaseConfig } = await (0, config_1.createNxReleaseConfig)(projectGraph, await (0, file_map_utils_1.createProjectFileMapUsingProjectGraph)(projectGraph), userProvidedReleaseConfig);
         if (configError) {
             return await (0, config_1.handleNxReleaseConfigError)(configError);
         }

package/src/command-line/release/release.js

@@ -88,17 +88,17 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
         const planFiles = new Set();
         releaseGroups.forEach((group) => {
-            if (group.versionPlans) {
+            if (group.resolvedVersionPlans) {
                 if (group.name === config_1.IMPLICIT_DEFAULT_RELEASE_GROUP) {
                     output_1.output.logSingleLine(`Removing version plan files`);
                 }
                 else {
                     output_1.output.logSingleLine(`Removing version plan files for group ${group.name}`);
                 }
-                group.versionPlans.forEach((plan) => {
+                group.resolvedVersionPlans.forEach((plan) => {
                     if (!args.dryRun) {
                         (0, fs_extra_1.removeSync)(plan.absolutePath);
                         if (args.verbose) {

package/src/command-line/release/version.js

@@ -84,7 +84,7 @@ function createAPI(overrideReleaseConfig) {
             process.exit(1);
         }
         const rawVersionPlans = await (0, version_plans_1.readRawVersionPlans)();
-        (0, version_plans_1.setVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
+        (0, version_plans_1.setResolvedVersionPlansOnGroups)(rawVersionPlans, releaseGroups, Object.keys(projectGraph.nodes));
         if (args.deleteVersionPlans === undefined) {
             // default to not delete version plans after versioning as they may be needed for changelog generation
             args.deleteVersionPlans = false;

package/src/command-line/sync/command-object.d.ts

@@ -0,0 +1,6 @@
+import type { CommandModule } from 'yargs';
+export interface SyncArgs {
+    verbose?: boolean;
+}
+export declare const yargsSyncCommand: CommandModule<Record<string, unknown>, SyncArgs>;
+export declare const yargsSyncCheckCommand: CommandModule<Record<string, unknown>, SyncArgs>;

package/src/command-line/sync/command-object.js

@@ -0,0 +1,25 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.yargsSyncCheckCommand = exports.yargsSyncCommand = void 0;
+exports.yargsSyncCommand = {
+    command: 'sync',
+    describe: false,
+    builder: (yargs) => yargs.option('verbose', {
+        type: 'boolean',
+        description: 'Prints additional information about the commands (e.g., stack traces)',
+    }),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./sync')).then((m) => m.syncHandler(args)));
+    },
+};
+exports.yargsSyncCheckCommand = {
+    command: 'sync:check',
+    describe: false,
+    builder: (yargs) => yargs.option('verbose', {
+        type: 'boolean',
+        description: 'Prints additional information about the commands (e.g., stack traces)',
+    }),
+    handler: async (args) => {
+        process.exit(await Promise.resolve().then(() => require('./sync')).then((m) => m.syncHandler({ ...args, check: true })));
+    },
+};

package/src/command-line/sync/sync.d.ts

@@ -0,0 +1,6 @@
+import type { SyncArgs } from './command-object';
+interface SyncOptions extends SyncArgs {
+    check?: boolean;
+}
+export declare function syncHandler(options: SyncOptions): Promise<number>;
+export {};

package/src/command-line/sync/sync.js

@@ -0,0 +1,30 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.syncHandler = syncHandler;
+const project_graph_1 = require("../../project-graph/project-graph");
+const output_1 = require("../../utils/output");
+const params_1 = require("../../utils/params");
+const sync_generators_1 = require("../../utils/sync-generators");
+function syncHandler(options) {
+    if (options.verbose) {
+        process.env.NX_VERBOSE_LOGGING = 'true';
+    }
+    const isVerbose = process.env.NX_VERBOSE_LOGGING === 'true';
+    return (0, params_1.handleErrors)(isVerbose, async () => {
+        const projectGraph = await (0, project_graph_1.createProjectGraphAsync)();
+        const syncGenerators = await (0, sync_generators_1.collectAllRegisteredSyncGenerators)(projectGraph);
+        const results = await (0, sync_generators_1.getSyncGeneratorChanges)(syncGenerators);
+        if (!results.length) {
+            return 0;
+        }
+        if (options.check) {
+            output_1.output.error({
+                title: `The workspace is out of sync`,
+                bodyLines: (0, sync_generators_1.syncGeneratorResultsToMessageLines)(results),
+            });
+            return 1;
+        }
+        await (0, sync_generators_1.flushSyncGeneratorChanges)(results);
+        return 0;
+    });
+}

package/src/config/nx-json.d.ts

@@ -145,6 +145,13 @@ export interface NxReleaseConventionalCommitsConfiguration {
         } | boolean;
     } | boolean>;
 }
+export interface NxReleaseVersionPlansConfiguration {
+    /**
+     * Changes to files matching any of these optional patterns will be excluded from the affected project logic within the `nx release plan:check`
+     * command. This is useful for ignoring files that are not relevant to the versioning process, such as documentation or configuration files.
+     */
+    ignorePatternsForPlanCheck?: string[];
+}
 export interface NxReleaseConfiguration {
     /**
      * Shorthand for amending the projects which will be included in the implicit default release group (all projects by default).
@@ -193,7 +200,7 @@ export interface NxReleaseConfiguration {
          * Enables using version plans as a specifier source for versioning and
          * to determine changes for changelog generation.
          */
-        versionPlans?: boolean;
+        versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
     }>;
     /**
      * Configures the default value for all groups that don't explicitly state their own projectsRelationship.
@@ -264,7 +271,26 @@ export interface NxReleaseConfiguration {
      * Enables using version plans as a specifier source for versioning and
      * to determine changes for changelog generation.
      */
-    versionPlans?: boolean;
+    versionPlans?: NxReleaseVersionPlansConfiguration | boolean;
+}
+export interface NxSyncConfiguration {
+    /**
+     * List of workspace-wide sync generators to be run (not attached to targets).
+     */
+    globalGenerators?: string[];
+    /**
+     * Options for the sync generators.
+     */
+    generatorOptions?: {
+        [generatorName: string]: Record<string, unknown>;
+    };
+    /**
+     * Whether to automatically apply sync generator changes when running tasks.
+     * If not set, the user will be prompted.
+     * If set to `true`, the user will not be prompted and the changes will be applied.
+     * If set to `false`, the user will not be prompted and the changes will not be applied.
+     */
+    applyChanges?: boolean;
 }
 /**
  * Nx.json configuration
@@ -413,6 +439,10 @@ export interface NxJsonConfiguration<T = '*' | string[]> {
      * Set this to false to disable connection to Nx Cloud
      */
     neverConnectToCloud?: boolean;
+    /**
+     * Configuration for the `nx sync` command.
+     */
+    sync?: NxSyncConfiguration;
 }
 export type PluginConfiguration = string | ExpandedPluginConfiguration;
 export type ExpandedPluginConfiguration<T = unknown> = {

package/src/config/workspace-json-project-json.d.ts

@@ -217,4 +217,9 @@ export interface TargetConfiguration<T = any> {
      * Default is true
      */
     parallelism?: boolean;
+    /**
+     * List of generators to run before the target to ensure the workspace
+     * is up to date.
+     */
+    syncGenerators?: string[];
 }

package/src/daemon/client/client.d.ts

@@ -5,6 +5,7 @@ import { Task, TaskGraph } from '../../config/task-graph';
 import { ConfigurationSourceMaps } from '../../project-graph/utils/project-configuration-utils';
 import { NxWorkspaceFiles } from '../../native';
 import { TaskRun } from '../../utils/task-history';
+import type { SyncGeneratorChangesResult } from '../../utils/sync-generators';
 export type UnregisterCallback = () => void;
 export type ChangedFile = {
     path: string;
@@ -54,6 +55,10 @@ export declare class DaemonClient {
         [hash: string]: TaskRun[];
     }>;
     writeTaskRunsToHistory(taskRuns: TaskRun[]): Promise<void>;
+    getSyncGeneratorChanges(generators: string[]): Promise<SyncGeneratorChangesResult[]>;
+    flushSyncGeneratorChangesToDisk(generators: string[]): Promise<void>;
+    getRegisteredSyncGenerators(): Promise<string[]>;
+    updateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<void>;
     isServerAvailable(): Promise<boolean>;
     private sendToDaemonViaQueue;
     private setUpConnection;

package/src/daemon/client/client.js

@@ -26,6 +26,10 @@ const get_context_file_data_1 = require("../message-types/get-context-file-data"
 const get_files_in_directory_1 = require("../message-types/get-files-in-directory");
 const hash_glob_1 = require("../message-types/hash-glob");
 const force_shutdown_1 = require("../message-types/force-shutdown");
+const get_sync_generator_changes_1 = require("../message-types/get-sync-generator-changes");
+const get_registered_sync_generators_1 = require("../message-types/get-registered-sync-generators");
+const update_workspace_context_1 = require("../message-types/update-workspace-context");
+const flush_sync_generator_changes_to_disk_1 = require("../message-types/flush-sync-generator-changes-to-disk");
 const DAEMON_ENV_SETTINGS = {
     NX_PROJECT_GLOB_CACHE: 'false',
     NX_CACHE_PROJECTS_CONFIG: 'false',
@@ -245,6 +249,35 @@ class DaemonClient {
         };
         return this.sendMessageToDaemon(message);
     }
+    getSyncGeneratorChanges(generators) {
+        const message = {
+            type: get_sync_generator_changes_1.GET_SYNC_GENERATOR_CHANGES,
+            generators,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    flushSyncGeneratorChangesToDisk(generators) {
+        const message = {
+            type: flush_sync_generator_changes_to_disk_1.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK,
+            generators,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    getRegisteredSyncGenerators() {
+        const message = {
+            type: get_registered_sync_generators_1.GET_REGISTERED_SYNC_GENERATORS,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
+    updateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
+        const message = {
+            type: update_workspace_context_1.UPDATE_WORKSPACE_CONTEXT,
+            createdFiles,
+            updatedFiles,
+            deletedFiles,
+        };
+        return this.sendToDaemonViaQueue(message);
+    }
     async isServerAvailable() {
         return new Promise((resolve) => {
             try {

package/src/daemon/message-types/flush-sync-generator-changes-to-disk.d.ts

@@ -0,0 +1,6 @@
+export declare const FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK: "CLEAR_CACHED_SYNC_GENERATOR_CHANGES";
+export type HandleFlushSyncGeneratorChangesToDiskMessage = {
+    type: typeof FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK;
+    generators: string[];
+};
+export declare function isHandleFlushSyncGeneratorChangesToDiskMessage(message: unknown): message is HandleFlushSyncGeneratorChangesToDiskMessage;

package/src/daemon/message-types/flush-sync-generator-changes-to-disk.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK = void 0;
+exports.isHandleFlushSyncGeneratorChangesToDiskMessage = isHandleFlushSyncGeneratorChangesToDiskMessage;
+exports.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK = 'CLEAR_CACHED_SYNC_GENERATOR_CHANGES';
+function isHandleFlushSyncGeneratorChangesToDiskMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.FLUSH_SYNC_GENERATOR_CHANGES_TO_DISK);
+}

package/src/daemon/message-types/get-registered-sync-generators.d.ts

@@ -0,0 +1,5 @@
+export declare const GET_REGISTERED_SYNC_GENERATORS: "GET_REGISTERED_SYNC_GENERATORS";
+export type HandleGetRegisteredSyncGeneratorsMessage = {
+    type: typeof GET_REGISTERED_SYNC_GENERATORS;
+};
+export declare function isHandleGetRegisteredSyncGeneratorsMessage(message: unknown): message is HandleGetRegisteredSyncGeneratorsMessage;

package/src/daemon/message-types/get-registered-sync-generators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_REGISTERED_SYNC_GENERATORS = void 0;
+exports.isHandleGetRegisteredSyncGeneratorsMessage = isHandleGetRegisteredSyncGeneratorsMessage;
+exports.GET_REGISTERED_SYNC_GENERATORS = 'GET_REGISTERED_SYNC_GENERATORS';
+function isHandleGetRegisteredSyncGeneratorsMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_REGISTERED_SYNC_GENERATORS);
+}

package/src/daemon/message-types/get-sync-generator-changes.d.ts

@@ -0,0 +1,6 @@
+export declare const GET_SYNC_GENERATOR_CHANGES: "GET_SYNC_GENERATOR_CHANGES";
+export type HandleGetSyncGeneratorChangesMessage = {
+    type: typeof GET_SYNC_GENERATOR_CHANGES;
+    generators: string[];
+};
+export declare function isHandleGetSyncGeneratorChangesMessage(message: unknown): message is HandleGetSyncGeneratorChangesMessage;

package/src/daemon/message-types/get-sync-generator-changes.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GET_SYNC_GENERATOR_CHANGES = void 0;
+exports.isHandleGetSyncGeneratorChangesMessage = isHandleGetSyncGeneratorChangesMessage;
+exports.GET_SYNC_GENERATOR_CHANGES = 'GET_SYNC_GENERATOR_CHANGES';
+function isHandleGetSyncGeneratorChangesMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.GET_SYNC_GENERATOR_CHANGES);
+}

package/src/daemon/message-types/update-workspace-context.d.ts

@@ -0,0 +1,8 @@
+export declare const UPDATE_WORKSPACE_CONTEXT: "UPDATE_WORKSPACE_CONTEXT";
+export type HandleUpdateWorkspaceContextMessage = {
+    type: typeof UPDATE_WORKSPACE_CONTEXT;
+    createdFiles: string[];
+    updatedFiles: string[];
+    deletedFiles: string[];
+};
+export declare function isHandleUpdateWorkspaceContextMessage(message: unknown): message is HandleUpdateWorkspaceContextMessage;

package/src/daemon/message-types/update-workspace-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.UPDATE_WORKSPACE_CONTEXT = void 0;
+exports.isHandleUpdateWorkspaceContextMessage = isHandleUpdateWorkspaceContextMessage;
+exports.UPDATE_WORKSPACE_CONTEXT = 'UPDATE_WORKSPACE_CONTEXT';
+function isHandleUpdateWorkspaceContextMessage(message) {
+    return (typeof message === 'object' &&
+        message !== null &&
+        'type' in message &&
+        message['type'] === exports.UPDATE_WORKSPACE_CONTEXT);
+}

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleFlushSyncGeneratorChangesToDisk(generators: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-flush-sync-generator-changes-to-disk.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleFlushSyncGeneratorChangesToDisk = handleFlushSyncGeneratorChangesToDisk;
+const sync_generators_1 = require("./sync-generators");
+async function handleFlushSyncGeneratorChangesToDisk(generators) {
+    await (0, sync_generators_1.flushSyncGeneratorChangesToDisk)(generators);
+    return {
+        response: '{}',
+        description: 'handleFlushSyncGeneratorChangesToDisk',
+    };
+}

package/src/daemon/server/handle-get-registered-sync-generators.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetRegisteredSyncGenerators(): Promise<HandlerResult>;

package/src/daemon/server/handle-get-registered-sync-generators.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetRegisteredSyncGenerators = handleGetRegisteredSyncGenerators;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetRegisteredSyncGenerators() {
+    const syncGenerators = await (0, sync_generators_1.getCachedRegisteredSyncGenerators)();
+    return {
+        response: JSON.stringify(syncGenerators),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-get-sync-generator-changes.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleGetSyncGeneratorChanges(generators: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-get-sync-generator-changes.js

@@ -0,0 +1,17 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleGetSyncGeneratorChanges = handleGetSyncGeneratorChanges;
+const sync_generators_1 = require("./sync-generators");
+async function handleGetSyncGeneratorChanges(generators) {
+    const changes = await (0, sync_generators_1.getCachedSyncGeneratorChanges)(generators);
+    // strip out the content of the changes and any potential callback
+    const result = changes.map((change) => ({
+        generatorName: change.generatorName,
+        changes: change.changes.map((c) => ({ ...c, content: null })),
+        outOfSyncMessage: change.outOfSyncMessage,
+    }));
+    return {
+        response: JSON.stringify(result),
+        description: 'handleGetSyncGeneratorChanges',
+    };
+}

package/src/daemon/server/handle-update-workspace-context.d.ts

@@ -0,0 +1,2 @@
+import type { HandlerResult } from './server';
+export declare function handleUpdateWorkspaceContext(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): Promise<HandlerResult>;

package/src/daemon/server/handle-update-workspace-context.js

@@ -0,0 +1,11 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.handleUpdateWorkspaceContext = handleUpdateWorkspaceContext;
+const project_graph_incremental_recomputation_1 = require("./project-graph-incremental-recomputation");
+async function handleUpdateWorkspaceContext(createdFiles, updatedFiles, deletedFiles) {
+    (0, project_graph_incremental_recomputation_1.addUpdatedAndDeletedFiles)(createdFiles, updatedFiles, deletedFiles);
+    return {
+        response: '{}',
+        description: 'handleUpdateContextFiles',
+    };
+}

package/src/daemon/server/project-graph-incremental-recomputation.d.ts

@@ -20,4 +20,5 @@ export declare let currentProjectFileMapCache: FileMapCache | undefined;
 export declare let currentProjectGraph: ProjectGraph | undefined;
 export declare function getCachedSerializedProjectGraphPromise(): Promise<SerializedProjectGraph>;
 export declare function addUpdatedAndDeletedFiles(createdFiles: string[], updatedFiles: string[], deletedFiles: string[]): void;
+export declare function registerProjectGraphRecomputationListener(listener: (projectGraph: ProjectGraph) => void): void;
 export {};