nx-lifecycle 0.2.1 → 1.1.0

package/dist/lifecycle/lifecycle-internal.js

@@ -1,102 +1,102 @@
+import { readFile, writeFile } from 'node:fs/promises';
 import { deepEqual } from 'fast-equals';
-export class LifecycleInternal {
-    #normalizer;
-    #readFile;
-    #writeFile;
-    #formatFiles;
-    #processNxAndProjectJsons;
-    #isNxJson;
-    #isProjectJson;
-    #logger;
-    lifecycleInternal;
-    constructor(normalizer, readFile, writeFile, formatFiles, processNxAndProjectJsons, isNxJson, isProjectJson, logger){
-        this.#normalizer = normalizer;
-        this.#readFile = readFile;
-        this.#writeFile = writeFile;
-        this.#formatFiles = formatFiles;
-        this.#processNxAndProjectJsons = processNxAndProjectJsons;
-        this.#isNxJson = isNxJson;
-        this.#isProjectJson = isProjectJson;
-        this.#logger = logger;
-        this.lifecycleInternal = this.#lifecycleInternal.bind(this);
-    }
-    async #lifecycleInternal(options, context) {
-        const normalized = await this.#normalizer.normalizeOptions(options, context);
-        const { nxJson, projectJsons } = await this.#loadJsonConfigs(normalized);
-        const { processedNxJson, processedProjectJsons } = this.#processNxAndProjectJsons({
-            nxJson: nxJson.data,
-            projectJsons: projectJsons.map(({ data })=>data),
-            options: normalized
-        });
-        await this.#saveJsonConfigs({
-            jsons: [
-                {
-                    ...nxJson,
-                    processed: processedNxJson
-                },
-                ...projectJsons.map((projectJson, i)=>({
-                        ...projectJson,
-                        processed: processedProjectJsons[i]
-                    }))
-            ],
-            options: normalized
+import { formatFiles } from 'format-file';
+import { assertNxJson, assertProjectJson } from '#schemas';
+import { normalizeOptions } from './normalizer.js';
+import { processNxAndProjectJsons } from './processor.js';
+const loadJsonConfigs = async ({ nxJsonPath, packageJsonPaths })=>{
+    const [rawNxJson, ...rawProjectJsons] = await Promise.all([
+        readFile(nxJsonPath, 'utf8'),
+        ...packageJsonPaths.map(async ({ name, path })=>({
+                name,
+                path,
+                rawData: await readFile(path, 'utf8')
+            }))
+    ]);
+    const parsedNxJson = JSON.parse(rawNxJson);
+    try {
+        assertNxJson(parsedNxJson);
+    } catch (err) {
+        throw new Error('Failed to parse nx.json', {
+            cause: err
         });
     }
-    async #loadJsonConfigs({ nxJsonPath, packageJsonPaths }) {
-        const [rawNxJson, ...rawProjectJsons] = await Promise.all([
-            this.#readFile(nxJsonPath, 'utf8'),
-            ...packageJsonPaths.map(async ({ name, path })=>({
-                    name,
-                    path,
-                    rawData: await this.#readFile(path, 'utf8')
-                }))
-        ]);
-        const parsedNxJson = JSON.parse(rawNxJson);
-        if (!this.#isNxJson(parsedNxJson)) {
-            throw new Error(`Failed to parse nx.json: ${JSON.stringify(this.#isNxJson.errors, null, 2)}`);
-        }
-        return {
-            nxJson: {
-                name: 'nx.json',
-                path: nxJsonPath,
-                data: parsedNxJson
-            },
-            projectJsons: rawProjectJsons.map(({ name, path, rawData })=>{
-                const data = JSON.parse(rawData);
-                if (!this.#isProjectJson(data)) {
-                    throw new Error(`Failed to parse ${path}: ${JSON.stringify(this.#isProjectJson.errors, null, 2)}`);
-                }
-                return {
-                    name,
-                    path,
-                    data
-                };
-            })
-        };
-    }
-    async #saveJsonConfigs({ jsons, options }) {
-        const filesToUpdate = [];
-        for (const { path, data, processed } of jsons){
-            if (deepEqual(data, processed)) {
-                continue;
+    return {
+        nxJson: {
+            name: 'nx.json',
+            path: nxJsonPath,
+            data: parsedNxJson
+        },
+        projectJsons: rawProjectJsons.map(({ name, path, rawData })=>{
+            const data = JSON.parse(rawData);
+            try {
+                assertProjectJson(data);
+            } catch (err) {
+                throw new Error(`Failed to parse ${path}`, {
+                    cause: err
+                });
             }
-            if (options.check) {
-                throw new Error(`File ${path} is not up to date`);
-            }
-            filesToUpdate.push({
+            return {
+                name,
                 path,
-                processed
-            });
+                data
+            };
+        })
+    };
+};
+const warnUndeclaredBindings = (bindings, projectJsons)=>{
+    const declaredTargets = new Set(projectJsons.flatMap((projectJson)=>Object.keys(projectJson.targets ?? {})));
+    for (const targetName of Object.keys(bindings)){
+        if (!declaredTargets.has(targetName)) {
+            console.warn(`Bound target ${targetName} is not declared in any project.json. Is it a typo?`);
         }
-        await Promise.all(filesToUpdate.map(async ({ path, processed })=>{
-            this.#logger.info(`Updating ${path}`);
-            if (options.dryRun) {
-                return;
-            }
-            return this.#writeFile(path, JSON.stringify(processed), 'utf8');
-        }));
-        await this.#formatFiles(filesToUpdate.map((file)=>file.path));
     }
-}
+};
+const saveJsonConfigs = async ({ jsons, options })=>{
+    const filesToUpdate = [];
+    for (const { path, data, processed } of jsons){
+        if (deepEqual(data, processed)) {
+            continue;
+        }
+        if (options.check) {
+            throw new Error(`File ${path} is not up to date`);
+        }
+        filesToUpdate.push({
+            path,
+            processed
+        });
+    }
+    for (const { path } of filesToUpdate){
+        console.info(`Updating ${path}`);
+    }
+    if (options.dryRun) {
+        return;
+    }
+    await Promise.all(filesToUpdate.map(async ({ path, processed })=>writeFile(path, JSON.stringify(processed), 'utf8')));
+    await formatFiles(filesToUpdate.map((file)=>file.path));
+};
+export const lifecycleInternal = async (options, context)=>{
+    const normalized = await normalizeOptions(options, context);
+    const { nxJson, projectJsons } = await loadJsonConfigs(normalized);
+    warnUndeclaredBindings(normalized.bindings, projectJsons.map(({ data })=>data));
+    const { processedNxJson, processedProjectJsons } = processNxAndProjectJsons({
+        nxJson: nxJson.data,
+        projectJsons: projectJsons.map(({ data })=>data),
+        options: normalized
+    });
+    await saveJsonConfigs({
+        jsons: [
+            {
+                ...nxJson,
+                processed: processedNxJson
+            },
+            ...projectJsons.map((projectJson, i)=>({
+                    ...projectJson,
+                    processed: processedProjectJsons[i]
+                }))
+        ],
+        options: normalized
+    });
+};
 
 //# sourceMappingURL=lifecycle-internal.js.map

package/dist/lifecycle/normalizer.d.ts

@@ -1,6 +1,4 @@
-import type { readFile as ReadFile } from 'node:fs/promises';
-import type { ParseCwd } from 'parse-cwd';
-import { type LifecycleOptions, type LifecycleOptionsOrConfig } from './schema.js';
+import type { LifecycleOptions, LifecycleOptionsOrConfig } from './schema.js';
 import type { NxContext } from './types.js';
 export interface NormalizedOptions {
     check: boolean;
@@ -13,13 +11,21 @@ export interface NormalizedOptions {
     stages: LifecycleOptions['stages'];
     bindings: LifecycleOptions['bindings'];
 }
+/**
+ * Options passed directly, or loaded from a config file.
+ *
+ * @param options - options, or where to load them from
+ * @returns stages and bindings, with any options passed directly
+ * @throws {Error} when the config file is invalid
+ */
+export declare const loadOptions: (options: LifecycleOptionsOrConfig) => Promise<LifecycleOptions>;
 /**
  * Standardizes the options passed to this executor,
  * based on input, reasonable defaults, and project state.
+ *
+ * @param options - options provided directly, or where to load them from
+ * @param context - workspace root and projects
+ * @returns options with defaults and file paths resolved
  */
-export declare class Normalizer {
-    #private;
-    constructor(isCI: () => boolean, parseCwd: ParseCwd, readFile: typeof ReadFile);
-    normalizeOptions(options: LifecycleOptionsOrConfig, context: NxContext): Promise<NormalizedOptions>;
-}
+export declare const normalizeOptions: (options: LifecycleOptionsOrConfig, context: NxContext) => Promise<NormalizedOptions>;
 //# sourceMappingURL=normalizer.d.ts.map

package/dist/lifecycle/normalizer.js

@@ -1,44 +1,37 @@
+import { readFile } from 'node:fs/promises';
 import Path from 'node:path';
+import { isCI } from 'ci-info';
+import { parseCwd } from 'parse-cwd';
 import { isLifecycleOptions } from './schema.js';
-export class Normalizer {
-    #isCI;
-    #parseCwd;
-    #readFile;
-    constructor(isCI, parseCwd, readFile){
-        this.#isCI = isCI;
-        this.#parseCwd = parseCwd;
-        this.#readFile = readFile;
+export const loadOptions = async (options)=>{
+    if ('stages' in options) {
+        return options;
     }
-    async normalizeOptions(options, context) {
-        const loadedOptions = await this.#loadOptions(options);
+    const cwd = await parseCwd(options.cwd);
+    const configFile = Path.join(cwd, options.configFile ?? './lifecycle.json');
+    const loadedConfig = await readFile(configFile, 'utf8');
+    const parsedConfig = JSON.parse(loadedConfig);
+    if (isLifecycleOptions(parsedConfig)) {
         return {
-            check: loadedOptions.check ?? this.#isCI(),
-            dryRun: loadedOptions.dryRun ?? false,
-            nxJsonPath: Path.join(context.root, 'nx.json'),
-            packageJsonPaths: context.projects.map((project)=>({
-                    name: project.name,
-                    path: Path.join(context.root, project.root, 'project.json')
-                })),
-            stages: loadedOptions.stages,
-            bindings: loadedOptions.bindings
+            ...parsedConfig,
+            ...options
         };
     }
-    async #loadOptions(options) {
-        if ('stages' in options) {
-            return options;
-        }
-        const cwd = await this.#parseCwd(options.cwd);
-        const configFile = Path.join(cwd, options.configFile ?? './lifecycle.json');
-        const loadedConfig = await this.#readFile(configFile, 'utf8');
-        const parsedConfig = JSON.parse(loadedConfig);
-        if (isLifecycleOptions(parsedConfig)) {
-            return {
-                ...parsedConfig,
-                ...options
-            };
-        }
-        throw new Error(`Invalid config loaded from ${configFile}`);
-    }
-}
+    throw new Error(`Invalid config loaded from ${configFile}`);
+};
+export const normalizeOptions = async (options, context)=>{
+    const loadedOptions = await loadOptions(options);
+    return {
+        check: loadedOptions.check ?? isCI,
+        dryRun: loadedOptions.dryRun ?? false,
+        nxJsonPath: Path.join(context.root, 'nx.json'),
+        packageJsonPaths: context.projects.map((project)=>({
+                name: project.name,
+                path: Path.join(context.root, project.root, 'project.json')
+            })),
+        stages: loadedOptions.stages,
+        bindings: loadedOptions.bindings
+    };
+};
 
 //# sourceMappingURL=normalizer.js.map

package/dist/lifecycle/processor.d.ts

@@ -1,7 +1,45 @@
-import { type NxJson, type ProjectJson } from '#schemas';
+import type { DependsOn, NxJson, ProjectJson } from '#schemas';
 import type { NormalizedOptions } from './normalizer.js';
-type ProcessorOptions = Pick<NormalizedOptions, 'bindings' | 'stages'>;
-export type NxAndProjectJsonProcessor = ({ nxJson, projectJsons, options, }: {
+export type ProcessorOptions = Pick<NormalizedOptions, 'bindings' | 'stages'>;
+export type LifecycleTarget = {
+    name: string;
+    stage: string;
+    dependsOn: DependsOn;
+} & ({
+    kind: 'anchor';
+} | ({
+    previousHook: string;
+} & ({
+    kind: 'base';
+    hasHooks: boolean;
+} | {
+    kind: 'hook';
+})));
+export type LifecycleTargets = Map<string, LifecycleTarget>;
+type LifecycleTargetWithHooks = Extract<LifecycleTarget, {
+    previousHook: string;
+}>;
+export type RegisteredTargets = Map<string, LifecycleTargetWithHooks>;
+export interface LifecyclePlan {
+    /**
+     * Every anchor, hook and stage target by name, with the dependencies its stage declares.
+     */
+    lifecycleTargets: LifecycleTargets;
+    /**
+     * Bound target names mapped to the lifecycle target they run in.
+     */
+    registeredTargets: RegisteredTargets;
+}
+/**
+ * Calculates the lifecycle targets, and the hook each bound target runs in.
+ * Shared by the executor, which writes the result to files, and the plugin, which infers it.
+ *
+ * @param options - stages and bindings
+ * @returns lifecycle targets and bound targets
+ * @throws if stages or bindings are inconsistent
+ */
+export declare const planLifecycle: (options: ProcessorOptions) => LifecyclePlan;
+export declare const processNxAndProjectJsons: ({ nxJson, projectJsons, options, }: {
     nxJson: NxJson;
     projectJsons: ProjectJson[];
     options: ProcessorOptions;
@@ -9,7 +47,5 @@ export type NxAndProjectJsonProcessor = ({ nxJson, projectJsons, options, }: {
     processedNxJson: NxJson;
     processedProjectJsons: ProjectJson[];
 };
-export declare const nxAndProjectJsonProcessorIdentifier: import("haywire").HaywireId<NxAndProjectJsonProcessor, null, null, false, false, false, false>;
-export declare const processNxAndProjectJsons: NxAndProjectJsonProcessor;
 export {};
 //# sourceMappingURL=processor.d.ts.map

package/dist/lifecycle/processor.js

@@ -1,4 +1,3 @@
-import { identifier } from 'haywire';
 import { isEmpty } from '#schemas';
 import { NOOP_EXECUTOR } from './constants.js';
 const calculateTargets = ({ stages })=>{
@@ -7,6 +6,7 @@ const calculateTargets = ({ stages })=>{
         const prefixHook = `${stageName}:_`;
         lifecycleTargets.set(prefixHook, {
             name: prefixHook,
+            stage: stageName,
             kind: 'anchor',
             dependsOn: stage.dependsOn ?? []
         });
@@ -16,6 +16,7 @@ const calculateTargets = ({ stages })=>{
             const hookName = `${stageName}:${hook}`;
             lifecycleTargets.set(hookName, {
                 name: hookName,
+                stage: stageName,
                 kind: 'hook',
                 dependsOn: [
                     previousHook
@@ -26,6 +27,7 @@ const calculateTargets = ({ stages })=>{
         }
         lifecycleTargets.set(stageName, {
             name: stageName,
+            stage: stageName,
             kind: 'base',
             dependsOn: [
                 previousHook
@@ -70,39 +72,46 @@ const calculateTargetsToRemove = ({ lifecycleTargets, nxJson })=>{
     }
     return targetsToRemove;
 };
-const removeDependencyTargets = ({ target, lifecycleTargets, targetsToRemove })=>{
-    if (target.dependsOn) {
-        return target.dependsOn.filter((dependency)=>{
-            const dependencyTarget = typeof dependency === 'string' ? dependency : dependency.target;
-            const normalized = dependencyTarget.replace(/^\^/u, '');
-            if (targetsToRemove.has(normalized)) {
-                return false;
-            }
+const getDependencyTarget = (dependency)=>typeof dependency === 'string' ? dependency : dependency.target;
+const normalizeDependencyTarget = (dependencyTarget)=>dependencyTarget.replace(/^\^/u, '');
+const removeDependencyTargets = ({ target, targetsToRemove })=>(target.dependsOn ?? []).filter((dependency)=>!targetsToRemove.has(normalizeDependencyTarget(getDependencyTarget(dependency))));
+const validateLifecycleDependencies = ({ lifecycleTargets, options })=>{
+    for (const [stageName, { dependsOn }] of Object.entries(options.stages)){
+        for (const dependency of dependsOn ?? []){
+            const dependencyTarget = getDependencyTarget(dependency);
+            const normalized = normalizeDependencyTarget(dependencyTarget);
             const lifecycleTarget = lifecycleTargets.get(normalized);
-            if (lifecycleTarget) {
-                return lifecycleTarget.kind === 'base';
+            if (lifecycleTarget && lifecycleTarget.kind !== 'base') {
+                const suggested = dependencyTarget.replace(normalized, lifecycleTarget.stage);
+                throw new Error(`Lifecycle stage ${stageName} cannot depend on ${dependencyTarget}, which is internal to stage ${lifecycleTarget.stage}. Depend on ${suggested} instead`);
             }
-            return true;
-        });
+        }
     }
-    return [];
 };
-const validateLifecycleDependencies = ({ lifecycleTargets, options, targetsToRemove })=>{
+const validateStaleDependencies = ({ options, targetsToRemove })=>{
     for (const [stageName, { dependsOn }] of Object.entries(options.stages)){
-        if (dependsOn) {
-            const filtered = removeDependencyTargets({
-                target: {
-                    dependsOn
-                },
-                lifecycleTargets,
-                targetsToRemove
-            });
-            if (filtered.length !== dependsOn.length) {
-                throw new Error(`Invalid dependency detected on lifecycle stage ${stageName}`);
+        for (const dependency of dependsOn ?? []){
+            const dependencyTarget = getDependencyTarget(dependency);
+            if (targetsToRemove.has(normalizeDependencyTarget(dependencyTarget))) {
+                throw new Error(`Lifecycle stage ${stageName} cannot depend on ${dependencyTarget}, which is a stale lifecycle target in nx.json`);
             }
         }
     }
 };
+export const planLifecycle = (options)=>{
+    const lifecycleTargets = calculateTargets(options);
+    validateLifecycleDependencies({
+        lifecycleTargets,
+        options
+    });
+    return {
+        lifecycleTargets,
+        registeredTargets: registerTargets({
+            options,
+            lifecycleTargets
+        })
+    };
+};
 const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToRemove })=>{
     const originalTargets = nxJson.targetDefaults ?? {};
     const targetDefaults = {
@@ -132,7 +141,6 @@ const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToR
                 ...originalTarget,
                 dependsOn: removeDependencyTargets({
                     target: originalTarget,
-                    lifecycleTargets,
                     targetsToRemove
                 })
             };
@@ -178,7 +186,6 @@ const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets,
             targets[targetName] = processedTarget;
             processedTarget.dependsOn = removeDependencyTargets({
                 target,
-                lifecycleTargets,
                 targetsToRemove
             });
             const lifecycleTarget = registeredTargets.get(targetName);
@@ -199,22 +206,16 @@ const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets,
         targets: processedTargets
     };
 };
-export const nxAndProjectJsonProcessorIdentifier = identifier();
 export const processNxAndProjectJsons = ({ nxJson, projectJsons, options })=>{
-    const lifecycleTargets = calculateTargets(options);
+    const { lifecycleTargets, registeredTargets } = planLifecycle(options);
     const targetsToRemove = calculateTargetsToRemove({
         lifecycleTargets,
         nxJson
     });
-    validateLifecycleDependencies({
-        lifecycleTargets,
+    validateStaleDependencies({
         options,
         targetsToRemove
     });
-    const registeredTargets = registerTargets({
-        options,
-        lifecycleTargets
-    });
     const processedNxJson = processNxJson({
         nxJson,
         lifecycleTargets,