nx-lifecycle 0.2.1 → 1.0.0

package/dist/lifecycle/index.js

@@ -1,6 +1,6 @@
 import { bind, identifier } from 'haywire';
-import { isNxJson, isNxJsonIdentifier, isProjectJson, isProjectJsonIdentifier } from '#schemas';
-import { dependenciesModule, formatFileIdentifier, isCiIdentifier, loggerIdentifier, parseCwdId, readFileIdentifier, writeFileIdentifier } from './depedencies.js';
+import { assertNxJson, assertNxJsonIdentifier, assertProjectJson, assertProjectJsonIdentifier } from '#schemas';
+import { dependenciesModule, formatFileIdentifier, isCiIdentifier, loggerIdentifier, parseCwdId, readFileIdentifier, writeFileIdentifier } from './dependencies.js';
 import { LifecycleInternal } from './lifecycle-internal.js';
 import { Normalizer } from './normalizer.js';
 import { nxAndProjectJsonProcessorIdentifier, processNxAndProjectJsons } from './processor.js';
@@ -13,13 +13,13 @@ export const lifecycleInternalModule = dependenciesModule.addBinding(bind(lifecy
     writeFileIdentifier,
     formatFileIdentifier,
     nxAndProjectJsonProcessorIdentifier,
-    isNxJsonIdentifier,
-    isProjectJsonIdentifier,
+    assertNxJsonIdentifier,
+    assertProjectJsonIdentifier,
     loggerIdentifier
 ])).addBinding(bind(Normalizer).withDependencies([
     isCiIdentifier.supplier(),
     parseCwdId,
     readFileIdentifier
-]).withConstructorProvider()).addBinding(bind(nxAndProjectJsonProcessorIdentifier).withInstance(processNxAndProjectJsons)).addBinding(bind(isNxJsonIdentifier).withInstance(isNxJson)).addBinding(bind(isProjectJsonIdentifier).withInstance(isProjectJson));
+]).withConstructorProvider()).addBinding(bind(nxAndProjectJsonProcessorIdentifier).withInstance(processNxAndProjectJsons)).addBinding(bind(assertNxJsonIdentifier).withInstance(assertNxJson)).addBinding(bind(assertProjectJsonIdentifier).withInstance(assertProjectJson));
 
 //# sourceMappingURL=index.js.map

package/dist/lifecycle/lifecycle-internal.d.ts

@@ -1,7 +1,7 @@
 import type { readFile as ReadFile, writeFile as WriteFile } from 'node:fs/promises';
 import type { FilesFormatter } from 'format-file';
-import type { IsNxJson, IsProjectJson } from '#schemas';
-import type { Logger } from './depedencies.js';
+import type { AssertNxJson, AssertProjectJson } from '#schemas';
+import type { Logger } from './dependencies.js';
 import type { Normalizer } from './normalizer.js';
 import type { NxAndProjectJsonProcessor } from './processor.js';
 import type { LifecycleOptionsOrConfig } from './schema.js';
@@ -17,6 +17,6 @@ export type ILifecycleInternal = (options: LifecycleOptionsOrConfig, context: Nx
 export declare class LifecycleInternal {
     #private;
     readonly lifecycleInternal: ILifecycleInternal;
-    constructor(normalizer: Normalizer, readFile: typeof ReadFile, writeFile: typeof WriteFile, formatFiles: FilesFormatter, processNxAndProjectJsons: NxAndProjectJsonProcessor, isNxJson: IsNxJson, isProjectJson: IsProjectJson, logger: Logger);
+    constructor(normalizer: Normalizer, readFile: typeof ReadFile, writeFile: typeof WriteFile, formatFiles: FilesFormatter, processNxAndProjectJsons: NxAndProjectJsonProcessor, assertNxJson: AssertNxJson, assertProjectJson: AssertProjectJson, logger: Logger);
 }
 //# sourceMappingURL=lifecycle-internal.d.ts.map

package/dist/lifecycle/lifecycle-internal.js

@@ -5,24 +5,25 @@ export class LifecycleInternal {
     #writeFile;
     #formatFiles;
     #processNxAndProjectJsons;
-    #isNxJson;
-    #isProjectJson;
+    #assertNxJson;
+    #assertProjectJson;
     #logger;
     lifecycleInternal;
-    constructor(normalizer, readFile, writeFile, formatFiles, processNxAndProjectJsons, isNxJson, isProjectJson, logger){
+    constructor(normalizer, readFile, writeFile, formatFiles, processNxAndProjectJsons, assertNxJson, assertProjectJson, logger){
         this.#normalizer = normalizer;
         this.#readFile = readFile;
         this.#writeFile = writeFile;
         this.#formatFiles = formatFiles;
         this.#processNxAndProjectJsons = processNxAndProjectJsons;
-        this.#isNxJson = isNxJson;
-        this.#isProjectJson = isProjectJson;
+        this.#assertNxJson = assertNxJson;
+        this.#assertProjectJson = assertProjectJson;
         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);
+        this.#warnUndeclaredBindings(normalized.bindings, projectJsons.map(({ data })=>data));
         const { processedNxJson, processedProjectJsons } = this.#processNxAndProjectJsons({
             nxJson: nxJson.data,
             projectJsons: projectJsons.map(({ data })=>data),
@@ -52,8 +53,12 @@ export class LifecycleInternal {
                 }))
         ]);
         const parsedNxJson = JSON.parse(rawNxJson);
-        if (!this.#isNxJson(parsedNxJson)) {
-            throw new Error(`Failed to parse nx.json: ${JSON.stringify(this.#isNxJson.errors, null, 2)}`);
+        try {
+            this.#assertNxJson(parsedNxJson);
+        } catch (err) {
+            throw new Error('Failed to parse nx.json', {
+                cause: err
+            });
         }
         return {
             nxJson: {
@@ -63,8 +68,12 @@ export class LifecycleInternal {
             },
             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)}`);
+                try {
+                    this.#assertProjectJson(data);
+                } catch (err) {
+                    throw new Error(`Failed to parse ${path}`, {
+                        cause: err
+                    });
                 }
                 return {
                     name,
@@ -74,6 +83,14 @@ export class LifecycleInternal {
             })
         };
     }
+    #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)) {
+                this.#logger.warn(`Bound target ${targetName} is not declared in any project.json. Is it a typo?`);
+            }
+        }
+    }
     async #saveJsonConfigs({ jsons, options }) {
         const filesToUpdate = [];
         for (const { path, data, processed } of jsons){

package/dist/lifecycle/normalizer.d.ts

@@ -1,6 +1,6 @@
 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;

package/dist/lifecycle/processor.d.ts

@@ -1,6 +1,44 @@
-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 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 type NxAndProjectJsonProcessor = ({ nxJson, projectJsons, options, }: {
     nxJson: NxJson;
     projectJsons: ProjectJson[];
@@ -9,7 +47,7 @@ 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 nxAndProjectJsonProcessorIdentifier: import("haywire").HaywireId<NxAndProjectJsonProcessor, null, null, false, false, false, false, false>;
 export declare const processNxAndProjectJsons: NxAndProjectJsonProcessor;
 export {};
 //# sourceMappingURL=processor.d.ts.map

package/dist/lifecycle/processor.js

@@ -7,6 +7,7 @@ const calculateTargets = ({ stages })=>{
         const prefixHook = `${stageName}:_`;
         lifecycleTargets.set(prefixHook, {
             name: prefixHook,
+            stage: stageName,
             kind: 'anchor',
             dependsOn: stage.dependsOn ?? []
         });
@@ -16,6 +17,7 @@ const calculateTargets = ({ stages })=>{
             const hookName = `${stageName}:${hook}`;
             lifecycleTargets.set(hookName, {
                 name: hookName,
+                stage: stageName,
                 kind: 'hook',
                 dependsOn: [
                     previousHook
@@ -26,6 +28,7 @@ const calculateTargets = ({ stages })=>{
         }
         lifecycleTargets.set(stageName, {
             name: stageName,
+            stage: stageName,
             kind: 'base',
             dependsOn: [
                 previousHook
@@ -70,39 +73,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 +142,6 @@ const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToR
                 ...originalTarget,
                 dependsOn: removeDependencyTargets({
                     target: originalTarget,
-                    lifecycleTargets,
                     targetsToRemove
                 })
             };
@@ -178,7 +187,6 @@ const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets,
             targets[targetName] = processedTarget;
             processedTarget.dependsOn = removeDependencyTargets({
                 target,
-                lifecycleTargets,
                 targetsToRemove
             });
             const lifecycleTarget = registeredTargets.get(targetName);
@@ -201,20 +209,15 @@ const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets,
 };
 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,