nx-lifecycle 1.0.0 → 1.1.1

package/dist/lifecycle/lifecycle-internal.js

@@ -1,119 +1,102 @@
+import { readFile, writeFile } from 'node:fs/promises';
 import { deepEqual } from 'fast-equals';
-export class LifecycleInternal {
-    #normalizer;
-    #readFile;
-    #writeFile;
-    #formatFiles;
-    #processNxAndProjectJsons;
-    #assertNxJson;
-    #assertProjectJson;
-    #logger;
-    lifecycleInternal;
-    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.#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),
-            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);
-        try {
-            this.#assertNxJson(parsedNxJson);
-        } catch (err) {
-            throw new Error('Failed to parse nx.json', {
-                cause: err
-            });
-        }
-        return {
-            nxJson: {
-                name: 'nx.json',
-                path: nxJsonPath,
-                data: parsedNxJson
-            },
-            projectJsons: rawProjectJsons.map(({ name, path, rawData })=>{
-                const data = JSON.parse(rawData);
-                try {
-                    this.#assertProjectJson(data);
-                } catch (err) {
-                    throw new Error(`Failed to parse ${path}`, {
-                        cause: err
-                    });
-                }
-                return {
-                    name,
-                    path,
-                    data
-                };
-            })
-        };
-    }
-    #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?`);
+    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
+                });
             }
+            return {
+                name,
+                path,
+                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?`);
         }
     }
-    async #saveJsonConfigs({ 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
-            });
+};
+const saveJsonConfigs = async ({ jsons, options })=>{
+    const filesToUpdate = [];
+    for (const { path, data, processed } of jsons){
+        if (deepEqual(data, processed)) {
+            continue;
         }
-        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));
+        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,5 +1,3 @@
-import type { readFile as ReadFile } from 'node:fs/promises';
-import type { ParseCwd } from 'parse-cwd';
 import type { LifecycleOptions, LifecycleOptionsOrConfig } from './schema.js';
 import type { NxContext } from './types.js';
 export interface NormalizedOptions {
@@ -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

@@ -39,7 +39,7 @@ export interface LifecyclePlan {
  * @throws if stages or bindings are inconsistent
  */
 export declare const planLifecycle: (options: ProcessorOptions) => LifecyclePlan;
-export type NxAndProjectJsonProcessor = ({ nxJson, projectJsons, options, }: {
+export declare const processNxAndProjectJsons: ({ nxJson, projectJsons, options, }: {
     nxJson: NxJson;
     projectJsons: ProjectJson[];
     options: ProcessorOptions;
@@ -47,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, 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 })=>{
@@ -61,12 +60,15 @@ const registerTargets = ({ lifecycleTargets, options })=>{
 };
 const calculateTargetsToRemove = ({ lifecycleTargets, nxJson })=>{
     const targetsToRemove = new Set();
-    for (const [targetName, target] of lifecycleTargets.entries()){
+    for (const [targetName, target] of lifecycleTargets){
         if (target.kind !== 'base') {
             targetsToRemove.add(targetName);
         }
     }
-    for (const [targetName, target] of Object.entries(nxJson.targetDefaults ?? {})){
+    if (!nxJson.targetDefaults) {
+        return targetsToRemove;
+    }
+    for (const [targetName, target] of Object.entries(nxJson.targetDefaults)){
         if (!lifecycleTargets.has(targetName) && '__lifecycle' in (target.configurations ?? {})) {
             targetsToRemove.add(targetName);
         }
@@ -78,12 +80,15 @@ const normalizeDependencyTarget = (dependencyTarget)=>dependencyTarget.replace(/
 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 ?? []){
+        if (!dependsOn) {
+            continue;
+        }
+        for (const dependency of dependsOn){
             const dependencyTarget = getDependencyTarget(dependency);
             const normalized = normalizeDependencyTarget(dependencyTarget);
             const lifecycleTarget = lifecycleTargets.get(normalized);
             if (lifecycleTarget && lifecycleTarget.kind !== 'base') {
-                const suggested = dependencyTarget.replace(normalized, lifecycleTarget.stage);
+                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`);
             }
         }
@@ -91,7 +96,10 @@ const validateLifecycleDependencies = ({ lifecycleTargets, options })=>{
 };
 const validateStaleDependencies = ({ options, targetsToRemove })=>{
     for (const [stageName, { dependsOn }] of Object.entries(options.stages)){
-        for (const dependency of dependsOn ?? []){
+        if (!dependsOn) {
+            continue;
+        }
+        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`);
@@ -119,7 +127,7 @@ const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToR
         ...originalTargets
     };
     const lifecycles = {};
-    for (const [targetName, target] of lifecycleTargets.entries()){
+    for (const [targetName, target] of lifecycleTargets){
         lifecycles[targetName] = {
             executor: NOOP_EXECUTOR,
             dependsOn: [
@@ -147,7 +155,7 @@ const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToR
             };
         }
     }
-    for (const [targetName, lifecycleTarget] of registeredTargets.entries()){
+    for (const [targetName, lifecycleTarget] of registeredTargets){
         const registeredTarget = targetDefaults[targetName] ?? {};
         registeredTarget.dependsOn ??= [];
         registeredTarget.dependsOn.push(lifecycleTarget.previousHook);
@@ -156,11 +164,12 @@ const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToR
     }
     Object.assign(targetDefaults, lifecycles);
     for (const [targetName, target] of Object.entries(targetDefaults)){
-        if (target.dependsOn.length === 0) {
-            const originalTarget = originalTargets[targetName] ?? {};
-            if (!originalTarget.dependsOn) {
-                delete target.dependsOn;
-            }
+        if (target.dependsOn.length > 0) {
+            continue;
+        }
+        const originalTarget = originalTargets[targetName] ?? {};
+        if (!originalTarget.dependsOn) {
+            delete target.dependsOn;
         }
     }
     return {
@@ -207,7 +216,6 @@ const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets,
         targets: processedTargets
     };
 };
-export const nxAndProjectJsonProcessorIdentifier = identifier();
 export const processNxAndProjectJsons = ({ nxJson, projectJsons, options })=>{
     const { lifecycleTargets, registeredTargets } = planLifecycle(options);
     const targetsToRemove = calculateTargetsToRemove({