nx-lifecycle 0.0.2

package/dist/executors/lifecycle/processor.js

@@ -0,0 +1,239 @@
+import { identifier } from 'haywire';
+import { isEmpty } from '#schemas';
+import { NOOP_EXECUTOR } from './constants.js';
+const calculateTargets = ({ stages })=>{
+    const lifecycleTargets = new Map();
+    for (const [stageName, stage] of Object.entries(stages)){
+        const prefixHook = `${stageName}:_`;
+        lifecycleTargets.set(prefixHook, {
+            name: prefixHook,
+            kind: 'anchor',
+            dependsOn: stage.dependsOn ?? []
+        });
+        let previousHook = prefixHook;
+        const hooks = stage.hooks ?? [];
+        for (const hook of hooks){
+            const hookName = `${stageName}:${hook}`;
+            lifecycleTargets.set(hookName, {
+                name: hookName,
+                kind: 'hook',
+                dependsOn: [
+                    previousHook
+                ],
+                previousHook
+            });
+            previousHook = hookName;
+        }
+        lifecycleTargets.set(stageName, {
+            name: stageName,
+            kind: 'base',
+            dependsOn: [
+                previousHook
+            ],
+            previousHook,
+            hasHooks: hooks.length > 0
+        });
+    }
+    return lifecycleTargets;
+};
+const registerTargets = ({ lifecycleTargets, options })=>{
+    const registeredTargets = new Map();
+    for (const [targetName, hookName] of Object.entries(options.bindings)){
+        if (lifecycleTargets.has(targetName)) {
+            throw new Error(`Overlap in lifecycle hook and target: ${targetName}`);
+        }
+        const hook = lifecycleTargets.get(hookName);
+        if (!hook) {
+            throw new Error(`Hook for target ${targetName} not found: ${hookName}`);
+        }
+        if (hook.kind === 'anchor') {
+            throw new Error(`Target ${targetName} cannot be part of anchor hook ${hook.name}`);
+        }
+        if (hook.kind === 'base' && hook.hasHooks) {
+            throw new Error(`Target ${targetName} cannot be part of base hook ${hook.name}. Use format ${hook.name}:<hook>`);
+        }
+        registeredTargets.set(targetName, hook);
+    }
+    return registeredTargets;
+};
+const calculateTargetsToRemove = ({ lifecycleTargets, nxJson })=>{
+    const targetsToRemove = new Set();
+    for (const [targetName, target] of lifecycleTargets.entries()){
+        if (target.kind !== 'base') {
+            targetsToRemove.add(targetName);
+        }
+    }
+    for (const [targetName, target] of Object.entries(nxJson.targetDefaults ?? {})){
+        if (!lifecycleTargets.has(targetName) && '__lifecycle' in (target.configurations ?? {})) {
+            targetsToRemove.add(targetName);
+        }
+    }
+    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 lifecycleTarget = lifecycleTargets.get(normalized);
+            if (lifecycleTarget) {
+                return lifecycleTarget.kind === 'base';
+            }
+            return true;
+        });
+    }
+    return [];
+};
+const validateLifecycleDependencies = ({ lifecycleTargets, 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}`);
+            }
+        }
+    }
+};
+const processNxJson = ({ nxJson, lifecycleTargets, registeredTargets, targetsToRemove })=>{
+    const originalTargets = nxJson.targetDefaults ?? {};
+    const targetDefaults = {
+        ...originalTargets
+    };
+    const lifecycles = {};
+    for (const [targetName, target] of lifecycleTargets.entries()){
+        lifecycles[targetName] = {
+            executor: NOOP_EXECUTOR,
+            dependsOn: [
+                ...target.dependsOn
+            ],
+            configurations: {
+                __lifecycle: {}
+            }
+        };
+    }
+    for (const [targetName, originalTarget] of Object.entries(targetDefaults)){
+        if (targetsToRemove.has(targetName) || lifecycleTargets.has(targetName)) {
+            if ('__lifecycle' in (originalTarget.configurations ?? {})) {
+                delete targetDefaults[targetName];
+            } else {
+                throw new Error(`Overlap in lifecycle hook and target: ${targetName}`);
+            }
+        } else {
+            targetDefaults[targetName] = {
+                ...originalTarget,
+                dependsOn: removeDependencyTargets({
+                    target: originalTarget,
+                    lifecycleTargets,
+                    targetsToRemove
+                })
+            };
+        }
+    }
+    for (const [targetName, lifecycleTarget] of registeredTargets.entries()){
+        const registeredTarget = targetDefaults[targetName] ?? {};
+        registeredTarget.dependsOn ??= [];
+        registeredTarget.dependsOn.push(lifecycleTarget.previousHook);
+        lifecycles[lifecycleTarget.name].dependsOn?.push(targetName);
+        targetDefaults[targetName] = registeredTarget;
+    }
+    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;
+            }
+        }
+    }
+    return {
+        ...nxJson,
+        targetDefaults
+    };
+};
+const processProjectJson = ({ projectJson, lifecycleTargets, registeredTargets, targetsToRemove })=>{
+    const originalTargets = projectJson.targets ?? {};
+    const targets = {
+        ...originalTargets
+    };
+    const lifecycles = {};
+    for (const targetName of lifecycleTargets.keys()){
+        lifecycles[targetName] = {};
+    }
+    for (const [targetName, target] of Object.entries(targets)){
+        if (targetsToRemove.has(targetName) || lifecycleTargets.has(targetName)) {
+            delete targets[targetName];
+        } else if (target.dependsOn) {
+            const processedTarget = {
+                ...target
+            };
+            targets[targetName] = processedTarget;
+            processedTarget.dependsOn = removeDependencyTargets({
+                target,
+                lifecycleTargets,
+                targetsToRemove
+            });
+            const lifecycleTarget = registeredTargets.get(targetName);
+            if (lifecycleTarget) {
+                processedTarget.dependsOn.push(lifecycleTarget.previousHook);
+            }
+        }
+    }
+    const processedTargets = {
+        ...targets,
+        ...lifecycles
+    };
+    if (!('targets' in projectJson) && isEmpty(processedTargets)) {
+        return projectJson;
+    }
+    return {
+        ...projectJson,
+        targets: processedTargets
+    };
+};
+export const nxAndProjectJsonProcessorIdentifier = identifier();
+export const processNxAndProjectJsons = ({ nxJson, projectJsons, options })=>{
+    const lifecycleTargets = calculateTargets(options);
+    const targetsToRemove = calculateTargetsToRemove({
+        lifecycleTargets,
+        nxJson
+    });
+    validateLifecycleDependencies({
+        lifecycleTargets,
+        options,
+        targetsToRemove
+    });
+    const registeredTargets = registerTargets({
+        options,
+        lifecycleTargets
+    });
+    const processedNxJson = processNxJson({
+        nxJson,
+        lifecycleTargets,
+        registeredTargets,
+        targetsToRemove
+    });
+    const processedProjectJsons = projectJsons.map((projectJson)=>processProjectJson({
+            projectJson,
+            lifecycleTargets,
+            targetsToRemove,
+            registeredTargets
+        }));
+    const response = {
+        processedNxJson,
+        processedProjectJsons
+    };
+    if (!('targetDefaults' in nxJson) && isEmpty(processedNxJson.targetDefaults)) {
+        delete response.processedNxJson.targetDefaults;
+    }
+    return response;
+};
+//# sourceMappingURL=processor.js.map

package/dist/executors/lifecycle/types.d.ts

@@ -0,0 +1,3 @@
+import type { ExecutorContext } from '@nx/devkit';
+export type SimpleExecutorContext = Pick<ExecutorContext, 'projectsConfigurations' | 'root'>;
+//# sourceMappingURL=types.d.ts.map

package/dist/executors/lifecycle/types.js

@@ -0,0 +1,2 @@
+export { };
+//# sourceMappingURL=types.js.map

package/dist/schemas/configurations.d.ts

@@ -0,0 +1,10 @@
+import { type SchemaType } from 'juniper';
+export declare const configurationsSchema: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
+    __lifecycle: never;
+}>) | (Partial<{
+    __lifecycle: import("juniper").EmptyObject;
+}> & Required<Pick<{
+    __lifecycle: import("juniper").EmptyObject;
+}, "__lifecycle">>), boolean>;
+export type Configurations = SchemaType<typeof configurationsSchema>;
+//# sourceMappingURL=configurations.d.ts.map

package/dist/schemas/configurations.js

@@ -0,0 +1,21 @@
+import { objectSchema } from 'juniper';
+export const configurationsSchema = objectSchema().oneOf([
+    objectSchema({
+        properties: {
+            __lifecycle: false
+        },
+        additionalProperties: true
+    }),
+    objectSchema({
+        properties: {
+            __lifecycle: objectSchema({
+                additionalProperties: false
+            })
+        },
+        required: [
+            '__lifecycle'
+        ],
+        additionalProperties: false
+    })
+]);
+//# sourceMappingURL=configurations.js.map

package/dist/schemas/depend-on.d.ts

@@ -0,0 +1,52 @@
+import { type SchemaType } from 'juniper';
+declare const dependencyObject: import("juniper").ObjectSchema<{
+    target: import("juniper").StringSchema<string, false>;
+    params: import("juniper").EnumSchema<string>;
+}, "target", boolean, import("juniper").EmptyIndex, Partial<{
+    dependencies: boolean;
+}> | (Partial<{
+    projects: string | string[];
+}> & Required<Pick<{
+    projects: string | string[];
+}, "projects">>), boolean>;
+export type DependencyObject = SchemaType<typeof dependencyObject>;
+export declare const dependsOnSchema: import("juniper").ArraySchema<(string | (Partial<{
+    projects: string | string[];
+}> & Required<Pick<{
+    projects: string | string[];
+}, "projects">> & Partial<{
+    target: string;
+    params: string;
+}> & Required<Pick<{
+    target: string;
+    params: string;
+}, "target">>) | (Partial<{
+    dependencies: boolean;
+}> & Partial<{
+    target: string;
+    params: string;
+}> & Required<Pick<{
+    target: string;
+    params: string;
+}, "target">>)) & (string | (Partial<{
+    projects: string | string[];
+}> & Required<Pick<{
+    projects: string | string[];
+}, "projects">> & Partial<{
+    target: string;
+    params: string;
+}> & Required<Pick<{
+    target: string;
+    params: string;
+}, "target">>) | (Partial<{
+    dependencies: boolean;
+}> & Partial<{
+    target: string;
+    params: string;
+}> & Required<Pick<{
+    target: string;
+    params: string;
+}, "target">>) | undefined), [], never, unknown, false>;
+export type DependsOn = SchemaType<typeof dependsOnSchema>;
+export {};
+//# sourceMappingURL=depend-on.d.ts.map

package/dist/schemas/depend-on.js

@@ -0,0 +1,37 @@
+import { arraySchema, booleanSchema, enumSchema, mergeSchema, objectSchema, stringSchema } from 'juniper';
+const dependencyObject = objectSchema({
+    properties: {
+        target: stringSchema(),
+        params: enumSchema({
+            enum: [
+                'forward',
+                'ignore'
+            ]
+        })
+    },
+    required: [
+        'target'
+    ]
+}).oneOf([
+    objectSchema({
+        properties: {
+            dependencies: booleanSchema()
+        }
+    }),
+    objectSchema({
+        properties: {
+            projects: mergeSchema().oneOf([
+                arraySchema(stringSchema()),
+                stringSchema()
+            ])
+        },
+        required: [
+            'projects'
+        ]
+    })
+]);
+export const dependsOnSchema = arraySchema(mergeSchema().oneOf([
+    stringSchema(),
+    dependencyObject
+]));
+//# sourceMappingURL=depend-on.js.map

package/dist/schemas/empty.d.ts

@@ -0,0 +1,6 @@
+import { type SchemaType } from 'juniper';
+declare const emptySchema: import("juniper").ObjectSchema<{}, never, false, import("juniper").EmptyIndex, unknown, false>;
+export type Empty = SchemaType<typeof emptySchema>;
+export declare const isEmpty: import("ajv").ValidateFunction<import("juniper").EmptyObject>;
+export {};
+//# sourceMappingURL=empty.d.ts.map

package/dist/schemas/empty.js

@@ -0,0 +1,7 @@
+import { objectSchema } from 'juniper';
+import { ajv } from './lib/ajv.js';
+const emptySchema = objectSchema({
+    additionalProperties: false
+});
+export const isEmpty = ajv.compile(emptySchema.toJSON());
+//# sourceMappingURL=empty.js.map

package/dist/schemas/index.d.ts

@@ -0,0 +1,7 @@
+export * from './empty.js';
+export * from './nx-json.js';
+export * from './project-json.js';
+export * from './configurations.js';
+export * from './depend-on.js';
+export * from './target.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/schemas/index.js

@@ -0,0 +1,7 @@
+export * from './empty.js';
+export * from './nx-json.js';
+export * from './project-json.js';
+export * from './configurations.js';
+export * from './depend-on.js';
+export * from './target.js';
+//# sourceMappingURL=index.js.map

package/dist/schemas/lib/ajv.d.ts

@@ -0,0 +1,3 @@
+import AjvDefault from 'ajv/dist/2020.js';
+export declare const ajv: AjvDefault.Ajv2020;
+//# sourceMappingURL=ajv.d.ts.map

package/dist/schemas/lib/ajv.js

@@ -0,0 +1,7 @@
+import AjvDefault from 'ajv/dist/2020.js';
+import { defaultImport } from 'default-import';
+const Ajv = defaultImport(AjvDefault);
+export const ajv = new Ajv({
+    strict: true
+});
+//# sourceMappingURL=ajv.js.map

package/dist/schemas/nx-json.d.ts

@@ -0,0 +1,60 @@
+import type { ErrorObject } from 'ajv';
+import { type SchemaType } from 'juniper';
+declare const nxJsonSchema: import("juniper").ObjectSchema<{
+    targetDefaults: import("juniper").ObjectSchema<{}, never, import("juniper").ObjectSchema<{
+        executor: import("juniper").StringSchema<string, false>;
+        dependsOn: import("juniper").ArraySchema<(string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>)) & (string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | undefined), [], never, unknown, false>;
+        configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
+            __lifecycle: never;
+        }>) | (Partial<{
+            __lifecycle: import("juniper").EmptyObject;
+        }> & Required<Pick<{
+            __lifecycle: import("juniper").EmptyObject;
+        }, "__lifecycle">>), boolean>;
+    }, never, boolean, import("juniper").EmptyIndex, unknown, false>, import("juniper").EmptyIndex, unknown, false>;
+}, never, true, import("juniper").EmptyIndex, unknown, false>;
+export type NxJson = SchemaType<typeof nxJsonSchema>;
+export interface IsNxJson {
+    (val: unknown): val is NxJson;
+    errors?: ErrorObject[] | null;
+}
+export declare const isNxJson: IsNxJson;
+export declare const isNxJsonIdentifier: import("haywire").HaywireId<IsNxJson, null, "nxJson", false, false, false, false>;
+export {};
+//# sourceMappingURL=nx-json.d.ts.map

package/dist/schemas/nx-json.js

@@ -0,0 +1,13 @@
+import { identifier } from 'haywire';
+import { objectSchema } from 'juniper';
+import { ajv } from './lib/ajv.js';
+import { allTargetsSchema } from './target.js';
+const nxJsonSchema = objectSchema({
+    properties: {
+        targetDefaults: allTargetsSchema
+    },
+    additionalProperties: true
+});
+export const isNxJson = ajv.compile(nxJsonSchema.toJSON());
+export const isNxJsonIdentifier = identifier().named('nxJson');
+//# sourceMappingURL=nx-json.js.map

package/dist/schemas/project-json.d.ts

@@ -0,0 +1,60 @@
+import type { ErrorObject } from 'ajv';
+import { type SchemaType } from 'juniper';
+declare const projectJsonSchema: import("juniper").ObjectSchema<{
+    targets: import("juniper").ObjectSchema<{}, never, import("juniper").ObjectSchema<{
+        executor: import("juniper").StringSchema<string, false>;
+        dependsOn: import("juniper").ArraySchema<(string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>)) & (string | (Partial<{
+            projects: string | string[];
+        }> & Required<Pick<{
+            projects: string | string[];
+        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | (Partial<{
+            dependencies: boolean;
+        }> & Partial<{
+            target: string;
+            params: string;
+        }> & Required<Pick<{
+            target: string;
+            params: string;
+        }, "target">>) | undefined), [], never, unknown, false>;
+        configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
+            __lifecycle: never;
+        }>) | (Partial<{
+            __lifecycle: import("juniper").EmptyObject;
+        }> & Required<Pick<{
+            __lifecycle: import("juniper").EmptyObject;
+        }, "__lifecycle">>), boolean>;
+    }, never, boolean, import("juniper").EmptyIndex, unknown, false>, import("juniper").EmptyIndex, unknown, false>;
+}, never, true, import("juniper").EmptyIndex, unknown, false>;
+export type ProjectJson = SchemaType<typeof projectJsonSchema>;
+export interface IsProjectJson {
+    (val: unknown): val is ProjectJson;
+    errors?: ErrorObject[] | null;
+}
+export declare const isProjectJson: IsProjectJson;
+export declare const isProjectJsonIdentifier: import("haywire").HaywireId<IsProjectJson, null, "projectJson", false, false, false, false>;
+export {};
+//# sourceMappingURL=project-json.d.ts.map

package/dist/schemas/project-json.js

@@ -0,0 +1,13 @@
+import { identifier } from 'haywire';
+import { objectSchema } from 'juniper';
+import { ajv } from './lib/ajv.js';
+import { allTargetsSchema } from './target.js';
+const projectJsonSchema = objectSchema({
+    properties: {
+        targets: allTargetsSchema
+    },
+    additionalProperties: true
+});
+export const isProjectJson = ajv.compile(projectJsonSchema.toJSON());
+export const isProjectJsonIdentifier = identifier().named('projectJson');
+//# sourceMappingURL=project-json.js.map

package/dist/schemas/target.d.ts

@@ -0,0 +1,99 @@
+import { type SchemaType } from 'juniper';
+declare const targetSchema: import("juniper").ObjectSchema<{
+    executor: import("juniper").StringSchema<string, false>;
+    dependsOn: import("juniper").ArraySchema<(string | (Partial<{
+        projects: string | string[];
+    }> & Required<Pick<{
+        projects: string | string[];
+    }, "projects">> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | (Partial<{
+        dependencies: boolean;
+    }> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>)) & (string | (Partial<{
+        projects: string | string[];
+    }> & Required<Pick<{
+        projects: string | string[];
+    }, "projects">> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | (Partial<{
+        dependencies: boolean;
+    }> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | undefined), [], never, unknown, false>;
+    configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
+        __lifecycle: never;
+    }>) | (Partial<{
+        __lifecycle: import("juniper").EmptyObject;
+    }> & Required<Pick<{
+        __lifecycle: import("juniper").EmptyObject;
+    }, "__lifecycle">>), boolean>;
+}, never, boolean, import("juniper").EmptyIndex, unknown, false>;
+export type Target = SchemaType<typeof targetSchema>;
+export declare const allTargetsSchema: import("juniper").ObjectSchema<{}, never, import("juniper").ObjectSchema<{
+    executor: import("juniper").StringSchema<string, false>;
+    dependsOn: import("juniper").ArraySchema<(string | (Partial<{
+        projects: string | string[];
+    }> & Required<Pick<{
+        projects: string | string[];
+    }, "projects">> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | (Partial<{
+        dependencies: boolean;
+    }> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>)) & (string | (Partial<{
+        projects: string | string[];
+    }> & Required<Pick<{
+        projects: string | string[];
+    }, "projects">> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | (Partial<{
+        dependencies: boolean;
+    }> & Partial<{
+        target: string;
+        params: string;
+    }> & Required<Pick<{
+        target: string;
+        params: string;
+    }, "target">>) | undefined), [], never, unknown, false>;
+    configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
+        __lifecycle: never;
+    }>) | (Partial<{
+        __lifecycle: import("juniper").EmptyObject;
+    }> & Required<Pick<{
+        __lifecycle: import("juniper").EmptyObject;
+    }, "__lifecycle">>), boolean>;
+}, never, boolean, import("juniper").EmptyIndex, unknown, false>, import("juniper").EmptyIndex, unknown, false>;
+export type AllTargets = SchemaType<typeof allTargetsSchema>;
+export {};
+//# sourceMappingURL=target.d.ts.map