nx-lifecycle 0.2.1 → 1.1.0

package/dist/lifecycle/schema.js

@@ -1,10 +1,10 @@
 import { arraySchema, booleanSchema, mergeSchema, objectSchema, stringSchema } from 'juniper';
+import { makeValidator } from 'juniper-validator';
 import { dependsOnSchema } from '#schemas';
-import { ajv } from '../schemas/lib/ajv.js';
 const checkAndDryRunSchema = objectSchema({
     properties: {
         $schema: stringSchema({
-            description: '',
+            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'),
         check: booleanSchema({
@@ -15,29 +15,38 @@ const checkAndDryRunSchema = objectSchema({
         })
     }
 });
-const lifecycleOptionsSchema = checkAndDryRunSchema.title('lifecycle').description('Inject Nx targets as high level workflows').properties({
-    stages: objectSchema({
-        description: 'Lifecycle stages by name',
-        properties: {},
-        additionalProperties: objectSchema({
-            properties: {
-                dependsOn: dependsOnSchema,
-                hooks: arraySchema(stringSchema())
-            }
-        })
-    }),
-    bindings: objectSchema({
-        description: 'Bind targets to hooks',
-        properties: {},
-        additionalProperties: stringSchema({
-            description: 'Name of hook in `stage:hook` format'
-        })
+export const stagesSchema = objectSchema({
+    description: 'Lifecycle stages by name',
+    properties: {},
+    additionalProperties: objectSchema({
+        properties: {
+            dependsOn: dependsOnSchema,
+            hooks: arraySchema(stringSchema())
+        }
+    })
+});
+export const bindingsSchema = objectSchema({
+    description: 'Bind targets to hooks',
+    properties: {},
+    additionalProperties: stringSchema({
+        description: 'Name of hook in `stage:hook` format'
     })
+});
+const lifecycleOptionsSchema = checkAndDryRunSchema.title('lifecycle').description('Inject Nx targets as high level workflows').properties({
+    stages: stagesSchema,
+    bindings: bindingsSchema
 }).required([
     'stages',
     'bindings'
 ]).additionalProperties(false);
-export const isLifecycleOptions = ajv.compile(lifecycleOptionsSchema.toJSON());
+export const lifecycleOptions = lifecycleOptionsSchema.toJSON({
+    schema: true
+});
+export const isLifecycleOptions = makeValidator(lifecycleOptions, {
+    formats: {
+        'uri-reference': true
+    }
+}).is;
 const lifecycleOptionsOrConfigSchema = mergeSchema().oneOf([
     lifecycleOptionsSchema,
     checkAndDryRunSchema.properties({
@@ -45,7 +54,7 @@ const lifecycleOptionsOrConfigSchema = mergeSchema().oneOf([
         cwd: stringSchema()
     }).additionalProperties(false)
 ]);
-export default lifecycleOptionsOrConfigSchema.metadata({
+export const lifecycleOptionsOrConfig = lifecycleOptionsOrConfigSchema.metadata({
     version: 1,
     outputCapture: 'direct-nodejs',
     cli: 'nx'

package/dist/plugin/index.d.ts

@@ -0,0 +1,7 @@
+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 { createDependencies, createNodes } from './lifecycle-plugin.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugin/index.js

@@ -0,0 +1,4 @@
+export const name = 'nx-lifecycle';
+export { createDependencies, createNodes } from './lifecycle-plugin.js';
+
+//# sourceMappingURL=index.js.map

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

@@ -0,0 +1,24 @@
+import type { CreateDependenciesContext, CreateNodes } from '@nx/devkit';
+import type { LifecyclePlan } from '../lifecycle/processor.js';
+import type { LifecyclePluginOptions } from './schema.js';
+/**
+ * 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.
+ * 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 const createDependencies: (options: LifecyclePluginOptions | undefined, context: CreateDependenciesContext) => [];
+//# sourceMappingURL=lifecycle-plugin.d.ts.map

package/dist/plugin/lifecycle-plugin.js

@@ -0,0 +1,145 @@
+import Path from 'node:path';
+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`;
+};
+const normalizeDependency = (dependency)=>{
+    if (typeof dependency !== 'string') {
+        return dependency;
+    }
+    if (dependency.startsWith('^')) {
+        return {
+            target: dependency.slice(1),
+            dependencies: true
+        };
+    }
+    return {
+        target: dependency
+    };
+};
+const dependsOnIncludes = (dependsOn, expected)=>{
+    const normalizedExpected = normalizeDependency(expected);
+    return (dependsOn ?? []).some((dependency)=>deepEqual(normalizeDependency(dependency), normalizedExpected));
+};
+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)))) {
+            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;
+        }
+        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)) {
+            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)) {
+            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 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
+        });
+    }
+    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 (targetName in declaredTargets) {
+            targets[lifecycleTarget.name].dependsOn.push(targetName);
+            targets[targetName] = {
+                dependsOn: [
+                    lifecycleTarget.previousHook
+                ]
+            };
+        }
+    }
+    return {
+        projects: {
+            [Path.dirname(projectJsonPath)]: {
+                targets
+            }
+        }
+    };
+};
+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 Object.keys(project.targets ?? {})){
+            definedTargets.add(targetName);
+        }
+    }
+    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/{executors/lifecycle/index.d.cts → plugin/schema.d.ts}

@@ -1,31 +1,20 @@
-declare const _default: import("nx-plugin-handler").RawHandler<(Partial<{
-    $schema: string;
-    check: boolean;
-    dryRun: boolean;
-    stages: Record<string, Partial<{
-        dependsOn: ((string | (Partial<{
-            projects: string | string[];
-        }> & Required<Pick<{
-            projects: string | string[];
-        }, "projects">> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>) | (Partial<{
+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<{
             dependencies: boolean;
+            projects: never;
         }> & 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 & Partial<{
+            dependencies: boolean;
+            projects: never;
+        }> & Partial<{
             target: string;
             params: string;
         }> & Required<Pick<{
@@ -33,24 +22,18 @@ declare const _default: import("nx-plugin-handler").RawHandler<(Partial<{
             params: string;
         }, "target">>) | (Partial<{
             dependencies: boolean;
+            projects: never;
         }> & Partial<{
             target: string;
             params: string;
         }> & Required<Pick<{
             target: string;
             params: string;
-        }, "target">>) | undefined))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}> & Required<Pick<{
-    $schema: string;
-    check: boolean;
-    dryRun: boolean;
-    stages: Record<string, Partial<{
-        dependsOn: ((string | (Partial<{
+        }, "target">> & string) | (Partial<{
+            dependencies: never;
             projects: string | string[];
         }> & Required<Pick<{
+            dependencies: never;
             projects: string | string[];
         }, "projects">> & Partial<{
             target: string;
@@ -58,17 +41,11 @@ declare const _default: import("nx-plugin-handler").RawHandler<(Partial<{
         }> & Required<Pick<{
             target: string;
             params: string;
-        }, "target">>) | (Partial<{
-            dependencies: boolean;
-        }> & Partial<{
-            target: string;
-            params: string;
-        }> & Required<Pick<{
-            target: string;
-            params: string;
-        }, "target">>)) & (string | (Partial<{
+        }, "target">>) | (string & Partial<{
+            dependencies: never;
             projects: string | string[];
         }> & Required<Pick<{
+            dependencies: never;
             projects: string | string[];
         }, "projects">> & Partial<{
             target: string;
@@ -77,23 +54,23 @@ declare const _default: import("nx-plugin-handler").RawHandler<(Partial<{
             target: string;
             params: string;
         }, "target">>) | (Partial<{
-            dependencies: boolean;
-        }> & 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">>) | undefined))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}, "stages" | "bindings">>) | Partial<{
-    $schema: string;
-    check: boolean;
-    dryRun: boolean;
-    configFile: string;
-    cwd: string;
-}>>;
-export default _default;
-//# sourceMappingURL=index.d.cts.map
+        }, "target">> & string), [], never, unknown, false>;
+        hooks: import("juniper").ArraySchema<string, [], never, unknown, false>;
+    }, never, boolean, import("juniper").EmptyIndex, unknown, false>, import("juniper").EmptyIndex, unknown, false>;
+    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: JuniperValidator<LifecyclePluginOptions>['assert'];
+export {};
+//# sourceMappingURL=schema.d.ts.map

package/dist/plugin/schema.js

@@ -0,0 +1,19 @@
+import { objectSchema } from 'juniper';
+import { makeValidator } from 'juniper-validator';
+import { bindingsSchema, stagesSchema } from '../lifecycle/schema.js';
+const lifecyclePluginOptionsSchema = objectSchema({
+    title: 'nx-lifecycle plugin',
+    description: 'Infer Nx targets as high level workflows',
+    properties: {
+        stages: stagesSchema,
+        bindings: bindingsSchema
+    },
+    required: [
+        'stages',
+        'bindings'
+    ],
+    additionalProperties: false
+});
+export const assertLifecyclePluginOptions = makeValidator(lifecyclePluginOptionsSchema).assert;
+
+//# sourceMappingURL=schema.js.map

package/dist/schemas/configurations.d.ts

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

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

@@ -1,20 +1,31 @@
-import { type SchemaType } from 'juniper';
+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;
+    projects: never;
 }> | (Partial<{
+    dependencies: never;
     projects: string | string[];
 }> & Required<Pick<{
+    dependencies: never;
     projects: string | string[];
 }, "projects">>), boolean>;
 export type DependencyObject = SchemaType<typeof dependencyObject>;
-export declare const dependsOnSchema: import("juniper").ArraySchema<(string | (Partial<{
-    projects: string | string[];
+export declare const dependsOnSchema: import("juniper").ArraySchema<string | (Partial<{
+    dependencies: boolean;
+    projects: never;
+}> & Partial<{
+    target: string;
+    params: string;
 }> & Required<Pick<{
-    projects: string | string[];
-}, "projects">> & Partial<{
+    target: string;
+    params: string;
+}, "target">>) | (string & Partial<{
+    dependencies: boolean;
+    projects: never;
+}> & Partial<{
     target: string;
     params: string;
 }> & Required<Pick<{
@@ -22,15 +33,30 @@ export declare const dependsOnSchema: import("juniper").ArraySchema<(string | (P
     params: string;
 }, "target">>) | (Partial<{
     dependencies: boolean;
+    projects: never;
 }> & Partial<{
     target: string;
     params: string;
 }> & Required<Pick<{
     target: string;
     params: string;
-}, "target">>)) & (string | (Partial<{
+}, "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;
@@ -39,14 +65,18 @@ export declare const dependsOnSchema: import("juniper").ArraySchema<(string | (P
     target: string;
     params: string;
 }, "target">>) | (Partial<{
-    dependencies: boolean;
-}> & 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">>) | undefined), [], never, unknown, false>;
+}, "target">> & string), [], never, unknown, false>;
 export type DependsOn = SchemaType<typeof dependsOnSchema>;
 export {};
 //# sourceMappingURL=depend-on.d.ts.map

package/dist/schemas/depend-on.js

@@ -1,4 +1,4 @@
-import { arraySchema, booleanSchema, enumSchema, mergeSchema, objectSchema, stringSchema } from 'juniper';
+import { arraySchema, booleanSchema, enumSchema, mergeSchema, neverSchema, objectSchema, stringSchema } from 'juniper';
 const dependencyObject = objectSchema({
     properties: {
         target: stringSchema(),
@@ -15,11 +15,13 @@ const dependencyObject = objectSchema({
 }).oneOf([
     objectSchema({
         properties: {
-            dependencies: booleanSchema()
+            dependencies: booleanSchema(),
+            projects: neverSchema()
         }
     }),
     objectSchema({
         properties: {
+            dependencies: neverSchema(),
             projects: mergeSchema().oneOf([
                 arraySchema(stringSchema()),
                 stringSchema()

package/dist/schemas/empty.d.ts

@@ -1,6 +1,6 @@
-import { type SchemaType } from 'juniper';
+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 declare const isEmpty: (x: unknown) => x is import("juniper").EmptyObject;
 export {};
 //# sourceMappingURL=empty.d.ts.map

package/dist/schemas/empty.js

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

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

@@ -1,13 +1,21 @@
-import type { ErrorObject } from 'ajv';
-import { type SchemaType } from 'juniper';
+import type { SchemaType } from 'juniper';
+import type { JuniperValidator } from 'juniper-validator';
 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[];
+        dependsOn: import("juniper").ArraySchema<string | (Partial<{
+            dependencies: boolean;
+            projects: never;
+        }> & Partial<{
+            target: string;
+            params: string;
         }> & Required<Pick<{
-            projects: string | string[];
-        }, "projects">> & Partial<{
+            target: string;
+            params: string;
+        }, "target">>) | (string & Partial<{
+            dependencies: boolean;
+            projects: never;
+        }> & Partial<{
             target: string;
             params: string;
         }> & Required<Pick<{
@@ -15,15 +23,30 @@ declare const nxJsonSchema: import("juniper").ObjectSchema<{
             params: string;
         }, "target">>) | (Partial<{
             dependencies: boolean;
+            projects: never;
         }> & Partial<{
             target: string;
             params: string;
         }> & Required<Pick<{
             target: string;
             params: string;
-        }, "target">>)) & (string | (Partial<{
+        }, "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;
@@ -32,29 +55,28 @@ declare const nxJsonSchema: import("juniper").ObjectSchema<{
             target: string;
             params: string;
         }, "target">>) | (Partial<{
-            dependencies: boolean;
-        }> & 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">>) | undefined), [], never, unknown, false>;
-        configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Record<string, unknown> & Partial<{
-            __lifecycle: never;
-        }>) | (Partial<{
+        }, "target">> & string), [], never, unknown, false>;
+        configurations: import("juniper").ObjectSchema<{}, never, boolean, import("juniper").EmptyIndex, (Partial<{
             __lifecycle: import("juniper").EmptyObject;
         }> & Required<Pick<{
             __lifecycle: import("juniper").EmptyObject;
-        }, "__lifecycle">>), boolean>;
+        }, "__lifecycle">>) | (Record<string, unknown> & Partial<{
+            __lifecycle: never;
+        }>), 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 declare const assertNxJson: JuniperValidator<NxJson>['assert'];
 export {};
 //# sourceMappingURL=nx-json.d.ts.map