nx-lifecycle 1.0.0 → 1.1.0

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,8 +1,10 @@
 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`;
@@ -54,105 +56,90 @@ const validateProject = ({ targets = {} }, { lifecycleTargets, registeredTargets
     }
     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);
+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
+        });
     }
-    #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);
+    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)
+            }
+        };
     }
-    #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){
+    for (const [targetName, lifecycleTarget] of registeredTargets){
+        if (targetName in declaredTargets) {
+            targets[lifecycleTarget.name].dependsOn.push(targetName);
             targets[targetName] = {
-                executor: NOOP_EXECUTOR,
                 dependsOn: [
-                    ...lifecycleTarget.dependsOn
-                ],
-                metadata: {
-                    description: describeTarget(lifecycleTarget)
-                }
+                    lifecycleTarget.previousHook
+                ]
             };
         }
-        for (const [targetName, lifecycleTarget] of registeredTargets){
-            if (targetName in declaredTargets) {
-                targets[lifecycleTarget.name].dependsOn.push(targetName);
-                targets[targetName] = {
-                    dependsOn: [
-                        lifecycleTarget.previousHook
-                    ]
-                };
-            }
-        }
-        return {
-            projects: {
-                [Path.dirname(projectJsonPath)]: {
-                    targets
-                }
-            }
-        };
     }
-    #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?`);
-            }
+        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

package/dist/plugin/schema.d.ts

@@ -1,4 +1,5 @@
 import type { SchemaType } from 'juniper';
+import type { JuniperValidator } from 'juniper-validator';
 declare const lifecyclePluginOptionsSchema: import("juniper").ObjectSchema<{
     stages: import("juniper").ObjectSchema<{}, never, import("juniper").ObjectSchema<{
         dependsOn: import("juniper").ArraySchema<string | (Partial<{
@@ -70,284 +71,6 @@ declare const lifecyclePluginOptionsSchema: import("juniper").ObjectSchema<{
     bindings: import("juniper").ObjectSchema<{}, never, import("juniper").StringSchema<string, false>, import("juniper").EmptyIndex, unknown, false>;
 }, "bindings" | "stages", false, import("juniper").EmptyIndex, unknown, false>;
 export type LifecyclePluginOptions = SchemaType<typeof lifecyclePluginOptionsSchema>;
-export declare const assertLifecyclePluginOptions: (x: unknown) => asserts x is 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">>;
-export type AssertLifecyclePluginOptions = typeof assertLifecyclePluginOptions;
-export declare const assertLifecyclePluginOptionsId: import("haywire").HaywireId<(x: unknown) => asserts x is 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">>, null, null, false, false, false, false, false>;
+export declare const assertLifecyclePluginOptions: JuniperValidator<LifecyclePluginOptions>['assert'];
 export {};
 //# sourceMappingURL=schema.d.ts.map

package/dist/plugin/schema.js

@@ -1,4 +1,3 @@
-import { identifier } from 'haywire';
 import { objectSchema } from 'juniper';
 import { makeValidator } from 'juniper-validator';
 import { bindingsSchema, stagesSchema } from '../lifecycle/schema.js';
@@ -16,6 +15,5 @@ const lifecyclePluginOptionsSchema = objectSchema({
     additionalProperties: false
 });
 export const assertLifecyclePluginOptions = makeValidator(lifecyclePluginOptionsSchema).assert;
-export const assertLifecyclePluginOptionsId = identifier();
 
 //# sourceMappingURL=schema.js.map