nx-lifecycle 1.0.0 → 1.1.1

package/dist/lifecycle/schema.js

@@ -6,7 +6,7 @@ const checkAndDryRunSchema = objectSchema({
         $schema: stringSchema({
             description: 'Path or URL to the JSON schema for this file',
             format: 'uri-reference'
-        }).example('https://raw.githubusercontent.com/JacobLey/leyman/refs/heads/main/apps/nx-lifecycle/src/lifecycle/schema.json'),
+        }).example('https://raw.githubusercontent.com/JacobLey/leyman/refs/heads/main/apps/nx-lifecycle/out/schema.json'),
         check: booleanSchema({
             description: 'Fails if references are not already updated, will not overwrite. Defaults to true during CI, false otherwise.'
         }),
@@ -15,13 +15,14 @@ const checkAndDryRunSchema = objectSchema({
         })
     }
 });
+const hooksSchema = arraySchema(stringSchema());
 export const stagesSchema = objectSchema({
     description: 'Lifecycle stages by name',
     properties: {},
     additionalProperties: objectSchema({
         properties: {
             dependsOn: dependsOnSchema,
-            hooks: arraySchema(stringSchema())
+            hooks: hooksSchema
         }
     })
 });

package/dist/plugin/index.d.ts

@@ -3,281 +3,5 @@ export type { LifecyclePluginOptions } from './schema.js';
  * Plugin name, as Nx can't attach one to an ES module.
  */
 export declare const name = "nx-lifecycle";
-export declare const createNodes: import("@nx/devkit").CreateNodes<Partial<{
-    stages: Record<string, Partial<{
-        dependsOn: (string | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}> & Required<Pick<{
-    stages: Record<string, Partial<{
-        dependsOn: (string | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}, "bindings" | "stages">>>, createDependencies: (options: (Partial<{
-    stages: Record<string, Partial<{
-        dependsOn: (string | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}> & Required<Pick<{
-    stages: Record<string, Partial<{
-        dependsOn: (string | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: boolean;
-            projects: never;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (string & Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
-            dependencies: never;
-            projects: string | string[];
-        }> & Required<Pick<{
-            dependencies: never;
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">> & string))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}, "bindings" | "stages">>) | undefined, context: import("@nx/devkit").CreateDependenciesContext) => [];
+export { createDependencies, createNodes } from './lifecycle-plugin.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.js

@@ -1,6 +1,4 @@
-import { lifecyclePluginContainer } from './container.js';
-import { LifecyclePlugin } from './lifecycle-plugin.js';
 export const name = 'nx-lifecycle';
-export const { createNodes, createDependencies } = lifecyclePluginContainer.get(LifecyclePlugin);
+export { createDependencies, createNodes } from './lifecycle-plugin.js';
 
 //# sourceMappingURL=index.js.map

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

@@ -1,21 +1,24 @@
-import type { CreateDependencies, CreateNodes } from '@nx/devkit';
-import type { AssertProjectJson } from '#schemas';
-import type { PluginLogger, ReadJsonFile } from './dependencies.js';
-import type { AssertLifecyclePluginOptions, LifecyclePluginOptions } from './schema.js';
+import type { CreateDependenciesContext, CreateNodes } from '@nx/devkit';
+import type { LifecyclePlan } from '../lifecycle/processor.js';
+import type { LifecyclePluginOptions } from './schema.js';
 /**
- * Nx plugin that infers lifecycle targets, instead of writing them to `nx.json` and `project.json`.
- *
- * `createNodes` adds the anchor, hook and stage targets to every project with a `project.json`,
- * and wires the bound targets declared there.
+ * Validates plugin options, with errors Nx prints, and plans the lifecycle from them.
  *
+ * @param options - plugin options from `nx.json`
+ * @returns lifecycle targets and bindings
+ * @throws {Error} when options are invalid, or stages and bindings are inconsistent
+ */
+export declare const planPluginOptions: (options: LifecyclePluginOptions | undefined) => LifecyclePlan;
+export declare const createNodes: CreateNodes<LifecyclePluginOptions>;
+/**
  * Nx applies `nx.json` `targetDefaults` and `project.json` on top of inferred targets,
  * replacing `dependsOn` rather than merging it.
- * `createDependencies` runs on the merged configuration, and fails if a bound target lost its wiring.
+ * This runs on the merged configuration, and fails if a bound target lost its wiring.
+ *
+ * @param options - plugin options from `nx.json`
+ * @param context - merged project configurations
+ * @returns no extra dependencies
+ * @throws {Error} when options are invalid, or a bound target lost its wiring
  */
-export declare class LifecyclePlugin {
-    #private;
-    readonly createNodes: CreateNodes<LifecyclePluginOptions>;
-    readonly createDependencies: (...args: Parameters<CreateDependencies<LifecyclePluginOptions>>) => [];
-    constructor(assertOptions: AssertLifecyclePluginOptions, readJsonFile: ReadJsonFile, assertProjectJson: AssertProjectJson, logger: PluginLogger);
-}
+export declare const createDependencies: (options: LifecyclePluginOptions | undefined, context: CreateDependenciesContext) => [];
 //# sourceMappingURL=lifecycle-plugin.d.ts.map

package/dist/plugin/lifecycle-plugin.js

@@ -1,32 +1,28 @@
 import Path from 'node:path';
-import { createNodesFromFiles } from '@nx/devkit';
+import { createNodesFromFiles, logger, readJsonFile } from '@nx/devkit';
 import { deepEqual } from 'fast-equals';
+import { assertProjectJson } from '#schemas';
 import { NOOP_EXECUTOR } from '../lifecycle/constants.js';
 import { planLifecycle } from '../lifecycle/processor.js';
+import { assertLifecyclePluginOptions } from './schema.js';
 const describeTarget = ({ kind, name, stage })=>{
     if (kind === 'anchor') {
         return `Start of the ${stage} stage. Waits for the dependencies of the stage`;
     }
-    if (kind === 'hook') {
-        return `Runs the targets bound to ${name}`;
-    }
-    return `Runs the ${stage} stage`;
+    return kind === 'hook' ? `Runs the targets bound to ${name}` : `Runs the ${stage} stage`;
 };
 const normalizeDependency = (dependency)=>{
     if (typeof dependency !== 'string') {
         return dependency;
     }
-    if (dependency.startsWith('^')) {
-        return {
-            target: dependency.slice(1),
-            dependencies: true
-        };
-    }
-    return {
+    return dependency.startsWith('^') ? {
+        target: dependency.slice(1),
+        dependencies: true
+    } : {
         target: dependency
     };
 };
-const dependsOnIncludes = (dependsOn, expected)=>{
+const hasDependency = (dependsOn, expected)=>{
     const normalizedExpected = normalizeDependency(expected);
     return (dependsOn ?? []).some((dependency)=>deepEqual(normalizeDependency(dependency), normalizedExpected));
 };
@@ -34,125 +30,113 @@ const validateProject = ({ targets = {} }, { lifecycleTargets, registeredTargets
     const errors = [];
     for (const [targetName, lifecycleTarget] of lifecycleTargets){
         const target = targets[targetName];
-        if (target && (target.executor !== NOOP_EXECUTOR || !lifecycleTarget.dependsOn.every((dependency)=>dependsOnIncludes(target.dependsOn, dependency)))) {
+        if (target && (target.executor !== NOOP_EXECUTOR || lifecycleTarget.dependsOn.some((dependency)=>!hasDependency(target.dependsOn, dependency)))) {
             errors.push(`${targetName} is inferred by nx-lifecycle, but project.json or nx.json targetDefaults override it. Remove it from there`);
         }
     }
     for (const [targetName, lifecycleTarget] of registeredTargets){
         const target = targets[targetName];
-        const hook = targets[lifecycleTarget.name];
         if (!target) {
             continue;
         }
+        const hook = targets[lifecycleTarget.name];
         if (!hook) {
             errors.push(`${targetName} is bound to ${lifecycleTarget.name}, but nx-lifecycle only adds lifecycle targets to projects with a project.json. Add one`);
-        } else if (!dependsOnIncludes(hook.dependsOn, targetName)) {
+        } else if (!hasDependency(hook.dependsOn, targetName)) {
             errors.push(`${targetName} is bound to ${lifecycleTarget.name}, but is not declared in project.json. Declare it there so nx-lifecycle can wire it`);
-        } else if (!dependsOnIncludes(target.dependsOn, lifecycleTarget.previousHook)) {
+        } else if (!hasDependency(target.dependsOn, lifecycleTarget.previousHook)) {
             errors.push(`${targetName} is bound to ${lifecycleTarget.name}, so it must depend on ${lifecycleTarget.previousHook}. A dependsOn in project.json or nx.json targetDefaults replaces the inferred one, so add "${lifecycleTarget.previousHook}" to it`);
         }
     }
     return errors;
 };
-export class LifecyclePlugin {
-    #assertOptions;
-    #readJsonFile;
-    #assertProjectJson;
-    #logger;
-    createNodes;
-    createDependencies;
-    constructor(assertOptions, readJsonFile, assertProjectJson, logger){
-        this.#assertOptions = assertOptions;
-        this.#readJsonFile = readJsonFile;
-        this.#assertProjectJson = assertProjectJson;
-        this.#logger = logger;
-        this.createNodes = [
-            '**/project.json',
-            this.#createNodes.bind(this)
-        ];
-        this.createDependencies = this.#createDependencies.bind(this);
-    }
-    #plan(options) {
-        try {
-            this.#assertOptions(options);
-        } catch (err) {
-            const issues = err.cause;
-            throw new Error([
-                'Invalid nx-lifecycle plugin options in nx.json:',
-                ...issues.map(({ instancePath, message })=>`- options${instancePath} ${message}`)
-            ].join('\n'), {
-                cause: err
-            });
-        }
-        return planLifecycle(options);
-    }
-    async #createNodes(projectJsonPaths, options, context) {
-        const plan = this.#plan(options);
-        return createNodesFromFiles((projectJsonPath)=>this.#createProjectNode(projectJsonPath, plan, context), projectJsonPaths, options, context);
+export const planPluginOptions = (options)=>{
+    try {
+        assertLifecyclePluginOptions(options);
+    } catch (err) {
+        const issues = err.cause;
+        throw new Error([
+            'Invalid nx-lifecycle plugin options in nx.json:',
+            ...issues.map(({ instancePath, message })=>`- options${instancePath} ${message}`)
+        ].join('\n'), {
+            cause: err
+        });
     }
-    #createProjectNode(projectJsonPath, { lifecycleTargets, registeredTargets }, context) {
-        const projectJson = this.#readJsonFile(Path.join(context.workspaceRoot, projectJsonPath));
-        this.#assertProjectJson(projectJson);
-        const declaredTargets = projectJson.targets ?? {};
-        const targets = {};
-        for (const [targetName, lifecycleTarget] of lifecycleTargets){
-            targets[targetName] = {
-                executor: NOOP_EXECUTOR,
-                dependsOn: [
-                    ...lifecycleTarget.dependsOn
-                ],
-                metadata: {
-                    description: describeTarget(lifecycleTarget)
-                }
-            };
-        }
-        for (const [targetName, lifecycleTarget] of registeredTargets){
-            if (targetName in declaredTargets) {
-                targets[lifecycleTarget.name].dependsOn.push(targetName);
-                targets[targetName] = {
-                    dependsOn: [
-                        lifecycleTarget.previousHook
-                    ]
-                };
+    return planLifecycle(options);
+};
+const createProjectNode = (projectJsonPath, { lifecycleTargets, registeredTargets }, context)=>{
+    const projectJson = readJsonFile(Path.join(context.workspaceRoot, projectJsonPath));
+    assertProjectJson(projectJson);
+    const declaredTargets = projectJson.targets ?? {};
+    const targets = {};
+    for (const [targetName, lifecycleTarget] of lifecycleTargets){
+        targets[targetName] = {
+            executor: NOOP_EXECUTOR,
+            dependsOn: [
+                ...lifecycleTarget.dependsOn
+            ],
+            metadata: {
+                description: describeTarget(lifecycleTarget)
             }
+        };
+    }
+    for (const [targetName, lifecycleTarget] of registeredTargets){
+        if (!Object.hasOwn(declaredTargets, targetName)) {
+            continue;
         }
-        return {
-            projects: {
-                [Path.dirname(projectJsonPath)]: {
-                    targets
-                }
-            }
+        targets[lifecycleTarget.name].dependsOn.push(targetName);
+        targets[targetName] = {
+            dependsOn: [
+                lifecycleTarget.previousHook
+            ]
         };
     }
-    #createDependencies(options, context) {
-        const plan = this.#plan(options);
-        const errors = new Map();
-        const definedTargets = new Set();
-        for (const [projectName, project] of Object.entries(context.projects)){
-            for (const error of validateProject(project, plan)){
-                const projectNames = errors.get(error) ?? [];
-                projectNames.push(projectName);
-                errors.set(error, projectNames);
-            }
-            for (const targetName of Object.keys(project.targets ?? {})){
-                definedTargets.add(targetName);
+    return {
+        projects: {
+            [Path.dirname(projectJsonPath)]: {
+                targets
             }
         }
-        if (errors.size > 0) {
-            throw new Error([
-                'nx-lifecycle targets are not wired as configured:',
-                ...[
-                    ...errors
-                ].map(([error, projectNames])=>`- ${error}\n  Projects: ${projectNames.join(', ')}`)
-            ].join('\n'));
+    };
+};
+const createLifecycleNodes = async (projectJsonPaths, options, context)=>{
+    const lifecyclePlan = planPluginOptions(options);
+    return createNodesFromFiles((projectJsonPath)=>createProjectNode(projectJsonPath, lifecyclePlan, context), projectJsonPaths, options, context);
+};
+export const createNodes = [
+    '**/project.json',
+    createLifecycleNodes
+];
+export const createDependencies = (options, context)=>{
+    const lifecyclePlan = planPluginOptions(options);
+    const errors = new Map();
+    const definedTargets = new Set();
+    for (const [projectName, project] of Object.entries(context.projects)){
+        for (const error of validateProject(project, lifecyclePlan)){
+            const projectNames = errors.get(error) ?? [];
+            projectNames.push(projectName);
+            errors.set(error, projectNames);
         }
-        for (const targetName of plan.registeredTargets.keys()){
-            if (!definedTargets.has(targetName)) {
-                this.#logger.warn(`Bound target ${targetName} is not defined in any project. Is it a typo?`);
+        if (project.targets) {
+            for (const targetName of Object.keys(project.targets)){
+                definedTargets.add(targetName);
             }
         }
-        return [];
     }
-}
+    if (errors.size > 0) {
+        throw new Error([
+            'nx-lifecycle targets are not wired as configured:',
+            ...[
+                ...errors
+            ].map(([error, projectNames])=>`- ${error}\n  Projects: ${projectNames.join(', ')}`)
+        ].join('\n'));
+    }
+    for (const targetName of lifecyclePlan.registeredTargets.keys()){
+        if (!definedTargets.has(targetName)) {
+            logger.warn(`Bound target ${targetName} is not defined in any project. Is it a typo?`);
+        }
+    }
+    return [];
+};
 
 //# sourceMappingURL=lifecycle-plugin.js.map