nx-lifecycle 0.0.9 → 0.1.0

package/README.md

@@ -89,6 +89,8 @@ Register it as a target in a `project.json`:
         "lifecycle": {
             "executor": "nx-lifecycle:lifecycle",
             "options": {
+                "cwd": "{projectRoot}",
+                "configFile": "lifecycle.json"
                 "stages": {
                     "build": { 
                         "hooks": ["pre", "run", "post"], 
@@ -100,7 +102,7 @@ Register it as a target in a `project.json`:
                     }
                 },
                 "bindings": {
-                    "nx-tsc": "build:run",
+                    "tsc": "build:run",
                     "mocha": "test:run"
                 }
             }
@@ -109,29 +111,79 @@ Register it as a target in a `project.json`:
 }
 ```
 
-Note that this target only needs to be run once (not once per project) so it is recommended to put this somewhere like a root `project.json` to own this.
+Note that this target only needs to be run once (not once per project) so it is recommended to put this somewhere like a root `project.json` to own this. [Nx-lifecycle's own monorepo is managed in a non-published "main" package](https://github.com/JacobLey/leyman/blob/main/leyman/main/lifecycle.json).
 
 ## Usage
 
-Because the `lifecycle` executor manages target dependencies itself, it probably should not be executed along with targets that are normally executed, like the `build` and `test` targets in the example above.
+Because `lifecycle` manages target dependencies itself, it probably should not be executed along with targets that are normally executed, like the `build` and `test` targets in the example above.
 
 For example, this project's use of `nx-lifecycle` is part of a [local-only project](https://github.com/JacobLey/leyman/blob/main/leyman/main/project.json#L15) that is never deployed anywhere, and exists only to manage the repo itself.
 
-`nx-lifecycle` will produce additional targets in your `nx.json` and `project.json`s. These will all be backed by the [noop](https://nx.dev/nx-api/nx/executors/noop) executor, and have no need to invoke caching. In fact, you should never directly manage these commands, their dependencies, or their configurations.
+`nx-lifecycle` will produce additional targets in your `nx.json` and `project.json`s. These will all be backed by the [noop](https://nx.dev/nx-api/nx/executors/noop) executor, and have no need to invoke caching. In fact, you should never directly manage these commands, their dependencies, or their configurations. These changes should be included in your version control.
 
 You may declare one-off targets that _depend_ on these targets though, that is the whole point! You should able to declare a target depends on the build step, without having to explicitly manage how the build script is implemented.
 
 `nx-lifecycle` will use the `nx.json` to assign defaults, and will assign defaults to your targets that are assigned there. However that does not guarantee every target is actually executable by every project. You must declare the target in your `project.json` as well. Do not worry about copying `nx-lifecycle`'s targets over.
 
-## Executors
+Instead of providing all the stages and bindings in the package.json file, it is also possible to manage that in a separate file, and point the plugin at it.
 
-### lifecycle
+### As a plugin
+
+Specify `nx-lifecycle:lifecycle` as the executor. You can pass the `lifecycle.json` config file there, or may provide the config JSON directly inline as the options.
+
+```json
+// project.json
+{
+    "targets": {
+        "lifecycle": {
+            "executor": "nx-lifecycle:lifecycle",
+            "options": {
+                "cwd": "{projectRoot}",
+                "configFile": "my-lifecycle-config.json" // defaults to "lifecycle.json"
+            }
+        }
+    }
+}
+```
+
+Where the file is the options object
+
+```json
+// lifecycle.json
+{
+    "stages": {
+        "build": { 
+            "hooks": ["pre", "run", "post"], 
+            "dependsOn": ["^build"]
+        },
+        "test": {
+            "hooks": ["run", "report"],
+            "dependsOn": ["build"]
+        }
+    },
+    "bindings": {
+        "tsc": "build:run",
+        "mocha": "test:run"
+    }
+}
+```
+
+### As a CLI
+
+Alternatively, you may invoke this plugin as a CLI command. Similar to above, it is _recommended_ to include this dependency in some project that is outside the scope of your "normal" packages. Although it could conceptually be installed globally as well.
+
+`pnpx nx-lifecycle --help`
+`pnpx nx-lifecycle --config-file ./my-lifecycle.json --dry-run`
 
-Will update all `project.json`s and the `nx.json` with declared stages, and wire up dependencies to your bound targets, ensuring that you can reference your abstract targets, Nx will invoke the required targets in dependency order as necessary.
+It is not possible to pass the configuration directly to the CLI, and must use a config file.
 
-Requires configuration to execute.
+## Configuration
 
-#### configuration.stages
+Both the CLI and the plugin support providing a config file to manage lifecycle options. This file (defaults to `lifecycle.json`) contains configuraiton that specifies the different stages and bindings for your projects.
+
+The lifecycle executor can also provide all these options directly in the `project.json` if preferred.
+
+### configuration.stages
 
 Required. No default value.
 
@@ -144,7 +196,7 @@ It is an object, where every key is the name of a stage. The value is another ob
 - `dependsOn`
   - Accepts the same values as normal Nx [dependsOn](https://nx.dev/reference/project-configuration#dependson). Used to define relationship between stages, and their dependencies.
 
-#### configuration.bindings
+### configuration.bindings
 
 Required. No default value.
 
@@ -154,32 +206,26 @@ The value is an object mapping, where the key is the name of your specific targe
 
 __\*\*NOTE\*\*__ If the bound stage has `steps` defined, then you must bind to a specific step. If there are no steps, then you reference the stage directly.
 
-```
+```json
+// lifecycle.json
 {
-    "targets": {
-        "lifecycle": {
-            "executor": "nx-lifecycle:lifecycle",
-            "options": {
-                "stages": {
-                    "build": { 
-                        "dependsOn": ["^build"]
-                    },
-                    "test": {
-                        "hooks": ["run", "report"],
-                        "dependsOn": ["build"]
-                    }
-                },
-                "bindings": {
-                    "nx-tsc": "build",
-                    "mocha": "test:run"
-                }
-            }
+    "stages": {
+        "build": { 
+            "dependsOn": ["^build"]
+        },
+        "test": {
+            "hooks": ["run", "report"],
+            "dependsOn": ["build"]
         }
+    },
+    "bindings": {
+        "tsc": "build",
+        "mocha": "test:run"
     }
 }
 ```
 
-#### configuration.check
+### configuration.check
 
 `boolean`. Default `true` in CI environments, otherwise `false`.
 
@@ -187,10 +233,16 @@ If `true`, the executor will fail if the `nx.json` or any `project.json` is out
 
 Useful for ensuring that generated configs are up to date in version control before proceeding with deployments.
 
-#### configuration.dryRun
+### configuration.dryRun
 
 `boolean`. Default `false`.
 
 If `true`, will do everything except actually write the updated config files.
 
 Can still fail if `check` is `true`.
+
+## Executors
+
+### lifecycle
+
+Will update all `project.json`s and the `nx.json` with declared stages, and wire up dependencies to your bound targets, ensuring that you can reference your abstract targets, Nx will invoke the required targets in dependency order as necessary.

package/bin.mjs

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+
+export { default } from './dist/bin.js';

package/dist/bin.d.ts

@@ -0,0 +1,3 @@
+declare const _default: import("haywire-launcher").WrapperMain;
+export default _default;
+//# sourceMappingURL=bin.d.ts.map

package/dist/bin.js

@@ -0,0 +1,16 @@
+import { EntryScript } from "entry-script";
+import { bind, singletonScope } from 'haywire';
+import { launch } from 'haywire-launcher';
+import { LifecycleCli } from './cli.js';
+import { commandsId, commandsModule } from './commands/index.js';
+import { consoleErrorId, consoleLogId, exitCodeId } from './commands/lib/dependencies.js';
+export default launch(commandsModule.addBinding(bind(EntryScript).withDependencies([
+    LifecycleCli
+]).withProvider((cli)=>cli).scoped(singletonScope)).addBinding(bind(LifecycleCli).withDependencies([
+    commandsId.supplier(),
+    consoleLogId,
+    consoleErrorId,
+    exitCodeId
+]).withConstructorProvider().scoped(singletonScope)).toContainer());
+
+//# sourceMappingURL=bin.js.map

package/dist/cli.d.ts

@@ -0,0 +1,22 @@
+import { EntryScript } from 'entry-script';
+import type { Supplier } from 'haywire';
+import type { ConsoleLog, ExitCode } from './commands/lib/dependencies.js';
+import type { AbstractCommand } from './commands/lib/types.js';
+/**
+ * Lifecycle CLI. Run `./bin.mjs --help` for options.
+ *
+ * Uses `yargs` package for command line parsing and logic flow.
+ */
+export declare class LifecycleCli extends EntryScript {
+    #private;
+    constructor(getCommands: Supplier<AbstractCommand[]>, logger: ConsoleLog, errorLogger: ConsoleLog, exitCode: ExitCode);
+    /**
+     * Entry point to CLI script.
+     *
+     * Sets high level Yargs settings. Command/options logic is implemented in individual command modules.
+     *
+     * @param argv - process arguments
+     */
+    main(argv: string[]): Promise<void>;
+}
+//# sourceMappingURL=cli.d.ts.map

package/dist/cli.js

@@ -0,0 +1,45 @@
+import yargs from 'yargs';
+import { EntryScript } from "entry-script";
+export class LifecycleCli extends EntryScript {
+    #getCommands;
+    #logger;
+    #errorLogger;
+    #exitCode;
+    constructor(getCommands, logger, errorLogger, exitCode){
+        super();
+        this.#getCommands = getCommands;
+        this.#logger = logger;
+        this.#errorLogger = errorLogger;
+        this.#exitCode = exitCode;
+    }
+    async main(argv) {
+        const packageJson = await import('../package.json', {
+            with: {
+                type: 'json'
+            }
+        });
+        const yarg = yargs().scriptName('lifecycle').option({
+            cwd: {
+                type: 'string',
+                default: '.',
+                describe: 'Directory to resolve all other paths from'
+            }
+        }).strict().help().alias('help', 'info').version(packageJson.default.version);
+        for (const command of this.#getCommands()){
+            yarg.command(command);
+        }
+        await yarg.parseAsync(argv, {}, this.#yargsOutput.bind(this));
+    }
+    #yargsOutput(e, _argv, log) {
+        if (e) {
+            this.#exitCode(1);
+            if (log) {
+                this.#errorLogger(log);
+            }
+        } else if (log) {
+            this.#logger(log);
+        }
+    }
+}
+
+//# sourceMappingURL=cli.js.map

package/dist/commands/index.d.ts

@@ -0,0 +1,5 @@
+import type { AbstractCommand } from './lib/types.js';
+import { LifecycleCommand } from './lifecycle-command.js';
+export declare const commandsId: import("haywire").HaywireId<AbstractCommand[], null, null, false, false, false, false>;
+export declare const commandsModule: import("haywire").Module<[import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | null | undefined, null, "log">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | null, null, "log">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | undefined, null, "log">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog, null, "log">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | null | undefined, null, "error">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | null, null, "error">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog | undefined, null, "error">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ConsoleLog, null, "error">] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ExitCode | null | undefined, null, null>] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ExitCode | null, null, null>] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ExitCode | undefined, null, null>] | [import("haywire").NonExtendable<import("./lib/dependencies.js").ExitCode, null, null>] | [import("haywire").NonExtendable<import("@nx/devkit").ProjectGraph | null | undefined, null, null>] | [import("haywire").NonExtendable<import("@nx/devkit").ProjectGraph | null, null, null>] | [import("haywire").NonExtendable<import("@nx/devkit").ProjectGraph | undefined, null, null>] | [import("haywire").NonExtendable<import("@nx/devkit").ProjectGraph, null, null>] | [import("haywire").NonExtendable<string | null | undefined, null, "workspace-root">] | [import("haywire").NonExtendable<string | null, null, "workspace-root">] | [import("haywire").NonExtendable<string | undefined, null, "workspace-root">] | [import("haywire").NonExtendable<string, null, "workspace-root">] | [import("haywire").NonExtendable<typeof import("fs/promises").readFile | null | undefined, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").readFile | null, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").readFile | undefined, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").readFile, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").writeFile | null | undefined, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").writeFile | null, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").writeFile | undefined, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").writeFile, null, null>] | [import("haywire").NonExtendable<import("format-file").FilesFormatter | null | undefined, null, null>] | [import("haywire").NonExtendable<import("format-file").FilesFormatter | null, null, null>] | [import("haywire").NonExtendable<import("format-file").FilesFormatter | undefined, null, null>] | [import("haywire").NonExtendable<import("format-file").FilesFormatter, null, null>] | [import("haywire").NonExtendable<boolean | null | undefined, null, "isCI">] | [import("haywire").NonExtendable<boolean | null, null, "isCI">] | [import("haywire").NonExtendable<boolean | undefined, null, "isCI">] | [import("haywire").NonExtendable<boolean, null, "isCI">] | [import("haywire").NonExtendable<import("../lifecycle/depedencies.js").Logger | null | undefined, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/depedencies.js").Logger | null, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/depedencies.js").Logger | undefined, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/depedencies.js").Logger, null, null>] | [import("haywire").NonExtendable<import("parse-cwd").ParseCwd | null | undefined, null, null>] | [import("haywire").NonExtendable<import("parse-cwd").ParseCwd | null, null, null>] | [import("haywire").NonExtendable<import("parse-cwd").ParseCwd | undefined, null, null>] | [import("haywire").NonExtendable<import("parse-cwd").ParseCwd, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").ILifecycleInternal | null | undefined, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").ILifecycleInternal | null, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").ILifecycleInternal | undefined, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").ILifecycleInternal, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").LifecycleInternal, typeof import("../lifecycle/lifecycle-internal.js").LifecycleInternal, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").LifecycleInternal | null | undefined, typeof import("../lifecycle/lifecycle-internal.js").LifecycleInternal, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").LifecycleInternal | null, typeof import("../lifecycle/lifecycle-internal.js").LifecycleInternal, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").LifecycleInternal | undefined, typeof import("../lifecycle/lifecycle-internal.js").LifecycleInternal, null>] | [import("haywire").NonExtendable<import("../lifecycle/normalizer.js").Normalizer, typeof import("../lifecycle/normalizer.js").Normalizer, null>] | [import("haywire").NonExtendable<import("../lifecycle/processor.js").NxAndProjectJsonProcessor, null, null>] | [import("haywire").NonExtendable<import("../schemas/nx-json.js").IsNxJson, null, "nxJson">] | [import("haywire").NonExtendable<import("../schemas/project-json.js").IsProjectJson, null, "projectJson">] | [import("haywire").NonExtendable<import("../lifecycle/normalizer.js").Normalizer | null | undefined, typeof import("../lifecycle/normalizer.js").Normalizer, null>] | [import("haywire").NonExtendable<import("../lifecycle/normalizer.js").Normalizer | null, typeof import("../lifecycle/normalizer.js").Normalizer, null>] | [import("haywire").NonExtendable<import("../lifecycle/normalizer.js").Normalizer | undefined, typeof import("../lifecycle/normalizer.js").Normalizer, null>] | [import("haywire").NonExtendable<import("../lifecycle/processor.js").NxAndProjectJsonProcessor | null | undefined, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/processor.js").NxAndProjectJsonProcessor | null, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/processor.js").NxAndProjectJsonProcessor | undefined, null, null>] | [import("haywire").NonExtendable<import("../schemas/nx-json.js").IsNxJson | null | undefined, null, "nxJson">] | [import("haywire").NonExtendable<import("../schemas/nx-json.js").IsNxJson | null, null, "nxJson">] | [import("haywire").NonExtendable<import("../schemas/nx-json.js").IsNxJson | undefined, null, "nxJson">] | [import("haywire").NonExtendable<import("../schemas/project-json.js").IsProjectJson | null | undefined, null, "projectJson">] | [import("haywire").NonExtendable<import("../schemas/project-json.js").IsProjectJson | null, null, "projectJson">] | [import("haywire").NonExtendable<import("../schemas/project-json.js").IsProjectJson | undefined, null, "projectJson">] | [import("haywire").NonExtendable<AbstractCommand[] | null | undefined, null, null>] | [import("haywire").NonExtendable<AbstractCommand[] | null, null, null>] | [import("haywire").NonExtendable<AbstractCommand[] | undefined, null, null>] | [import("haywire").NonExtendable<AbstractCommand[], null, null>] | [import("haywire").NonExtendable<LifecycleCommand, typeof LifecycleCommand, null>] | [import("haywire").NonExtendable<LifecycleCommand | null | undefined, typeof LifecycleCommand, null>] | [import("haywire").NonExtendable<LifecycleCommand | null, typeof LifecycleCommand, null>] | [import("haywire").NonExtendable<LifecycleCommand | undefined, typeof LifecycleCommand, null>], [import("haywire").NonExtendable<import("@nx/devkit").ProjectGraph, null, null>] | [import("haywire").NonExtendable<string, null, "workspace-root">] | [import("haywire").NonExtendable<typeof import("fs/promises").readFile, null, null>] | [import("haywire").NonExtendable<typeof import("fs/promises").writeFile, null, null>] | [import("haywire").NonExtendable<import("format-file").FilesFormatter, null, null>] | [import("haywire").NonExtendable<boolean, null, "isCI">] | [import("haywire").NonExtendable<import("../lifecycle/depedencies.js").Logger, null, null>] | [import("haywire").NonExtendable<import("parse-cwd").ParseCwd, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").ILifecycleInternal, null, null>] | [import("haywire").NonExtendable<import("../lifecycle/lifecycle-internal.js").LifecycleInternal, typeof import("../lifecycle/lifecycle-internal.js").LifecycleInternal, null>] | [import("haywire").NonExtendable<import("../lifecycle/normalizer.js").Normalizer, typeof import("../lifecycle/normalizer.js").Normalizer, null>] | [import("haywire").NonExtendable<import("../lifecycle/processor.js").NxAndProjectJsonProcessor, null, null>] | [import("haywire").NonExtendable<import("../schemas/nx-json.js").IsNxJson, null, "nxJson">] | [import("haywire").NonExtendable<import("../schemas/project-json.js").IsProjectJson, null, "projectJson">] | [import("haywire").NonExtendable<LifecycleCommand, typeof LifecycleCommand, null>], true>;
+//# sourceMappingURL=index.d.ts.map

package/dist/commands/index.js

@@ -0,0 +1,14 @@
+import { bind, identifier } from 'haywire';
+import { lifecycleInternalId, lifecycleInternalModule } from '../lifecycle/index.js';
+import { dependenciesModule, projectGraphId, workspaceRootId } from './lib/dependencies.js';
+import { LifecycleCommand } from './lifecycle-command.js';
+export const commandsId = identifier();
+export const commandsModule = dependenciesModule.mergeModule(lifecycleInternalModule).addBinding(bind(commandsId).withDependencies([
+    LifecycleCommand
+]).withProvider((...commands)=>commands)).addBinding(bind(LifecycleCommand).withDependencies([
+    projectGraphId.supplier('async'),
+    workspaceRootId,
+    lifecycleInternalId
+]).withConstructorProvider());
+
+//# sourceMappingURL=index.js.map

package/dist/commands/lib/dependencies.d.ts

@@ -0,0 +1,10 @@
+import { type ProjectGraph } from '@nx/devkit';
+export type ConsoleLog = (log: unknown) => void;
+export declare const consoleLogId: import("haywire").HaywireId<ConsoleLog, null, "log", false, false, false, false>;
+export declare const consoleErrorId: import("haywire").HaywireId<ConsoleLog, null, "error", false, false, false, false>;
+export type ExitCode = (code: number) => void;
+export declare const exitCodeId: import("haywire").HaywireId<ExitCode, null, null, false, false, false, false>;
+export declare const projectGraphId: import("haywire").HaywireId<ProjectGraph, null, null, false, false, false, false>;
+export declare const workspaceRootId: import("haywire").HaywireId<string, null, "workspace-root", false, false, false, false>;
+export declare const dependenciesModule: import("haywire").Module<[import("haywire").NonExtendable<ConsoleLog | null | undefined, null, "log">] | [import("haywire").NonExtendable<ConsoleLog | null, null, "log">] | [import("haywire").NonExtendable<ConsoleLog | undefined, null, "log">] | [import("haywire").NonExtendable<ConsoleLog, null, "log">] | [import("haywire").NonExtendable<ConsoleLog | null | undefined, null, "error">] | [import("haywire").NonExtendable<ConsoleLog | null, null, "error">] | [import("haywire").NonExtendable<ConsoleLog | undefined, null, "error">] | [import("haywire").NonExtendable<ConsoleLog, null, "error">] | [import("haywire").NonExtendable<ExitCode | null | undefined, null, null>] | [import("haywire").NonExtendable<ExitCode | null, null, null>] | [import("haywire").NonExtendable<ExitCode | undefined, null, null>] | [import("haywire").NonExtendable<ExitCode, null, null>] | [import("haywire").NonExtendable<ProjectGraph | null | undefined, null, null>] | [import("haywire").NonExtendable<ProjectGraph | null, null, null>] | [import("haywire").NonExtendable<ProjectGraph | undefined, null, null>] | [import("haywire").NonExtendable<ProjectGraph, null, null>] | [import("haywire").NonExtendable<string | null | undefined, null, "workspace-root">] | [import("haywire").NonExtendable<string | null, null, "workspace-root">] | [import("haywire").NonExtendable<string | undefined, null, "workspace-root">] | [import("haywire").NonExtendable<string, null, "workspace-root">], never, true>;
+//# sourceMappingURL=dependencies.d.ts.map

package/dist/commands/lib/dependencies.js

@@ -0,0 +1,12 @@
+import { createProjectGraphAsync, workspaceRoot } from '@nx/devkit';
+import { bind, createModule, identifier, singletonScope } from 'haywire';
+export const consoleLogId = identifier().named('log');
+export const consoleErrorId = identifier().named('error');
+export const exitCodeId = identifier();
+export const projectGraphId = identifier();
+export const workspaceRootId = identifier().named('workspace-root');
+export const dependenciesModule = createModule(bind(consoleLogId).withInstance(console.log)).addBinding(bind(consoleErrorId).withInstance(console.error)).addBinding(bind(exitCodeId).withInstance((code)=>{
+    process.exitCode = code;
+})).addBinding(bind(projectGraphId).withAsyncGenerator(createProjectGraphAsync).scoped(singletonScope)).addBinding(bind(workspaceRootId).withInstance(workspaceRoot));
+
+//# sourceMappingURL=dependencies.js.map

package/dist/commands/lib/types.d.ts

@@ -0,0 +1,9 @@
+import type { CommandModule } from 'yargs';
+export interface LifecycleCommandInput {
+    cwd: string;
+}
+export type Command<ExtendedInput extends LifecycleCommandInput> = Pick<CommandModule<LifecycleCommandInput, ExtendedInput>, 'builder' | 'command' | 'describe' | 'handler'>;
+export interface AbstractCommand extends Pick<CommandModule<LifecycleCommandInput, LifecycleCommandInput>, 'builder' | 'command' | 'describe'> {
+    handler: (args: any) => Promise<void>;
+}
+//# sourceMappingURL=types.d.ts.map

package/dist/commands/lib/types.js

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

package/dist/commands/lifecycle-command.d.ts

@@ -0,0 +1,22 @@
+import type { ProjectGraph } from '@nx/devkit';
+import type { Argv } from 'yargs';
+import type { ILifecycleInternal } from '../lifecycle/lifecycle-internal.js';
+import type { Command, LifecycleCommandInput } from './lib/types.js';
+interface LifecycleCommandExtendedInput extends LifecycleCommandInput {
+    configFile: string;
+    ci: boolean;
+    dryRun: boolean;
+}
+/**
+ * Main `load-populate-files` command
+ */
+export declare class LifecycleCommand implements Command<LifecycleCommandExtendedInput> {
+    #private;
+    readonly command: string[];
+    readonly describe = "Inject Nx targets as high level workflows";
+    constructor(getProjectGraph: () => Promise<ProjectGraph>, workspaceRoot: string, lifecycleInternal: ILifecycleInternal);
+    builder(this: void, yargs: Argv<LifecycleCommandInput>): Argv<LifecycleCommandExtendedInput>;
+    handler(options: LifecycleCommandExtendedInput): Promise<void>;
+}
+export {};
+//# sourceMappingURL=lifecycle-command.d.ts.map

package/dist/commands/lifecycle-command.js

@@ -0,0 +1,54 @@
+import { isCI } from 'ci-info';
+export class LifecycleCommand {
+    command = [
+        '$0',
+        'lifecycle'
+    ];
+    describe = 'Inject Nx targets as high level workflows';
+    #getProjectGraph;
+    #workspaceRoot;
+    #lifecycleInternal;
+    constructor(getProjectGraph, workspaceRoot, lifecycleInternal){
+        this.#getProjectGraph = getProjectGraph;
+        this.#workspaceRoot = workspaceRoot;
+        this.#lifecycleInternal = lifecycleInternal;
+        this.handler = this.handler.bind(this);
+    }
+    builder(yargs) {
+        return yargs.options({
+            configFile: {
+                describe: 'File that exports data content to populate',
+                type: 'string',
+                default: 'lifecycle.json'
+            },
+            ci: {
+                describe: 'Fail if file is not up to date. Implies --dry-run',
+                type: 'boolean',
+                default: isCI,
+                alias: 'check'
+            },
+            dryRun: {
+                describe: 'Do not write file',
+                type: 'boolean',
+                default: false
+            }
+        }).strict();
+    }
+    async handler(options) {
+        const projectGraph = await this.#getProjectGraph();
+        await this.#lifecycleInternal({
+            configFile: options.configFile,
+            cwd: options.cwd,
+            check: options.ci,
+            dryRun: options.dryRun
+        }, {
+            root: this.#workspaceRoot,
+            projects: Object.values(projectGraph.nodes).map((node)=>({
+                    name: node.name,
+                    root: node.data.root
+                }))
+        });
+    }
+}
+
+//# sourceMappingURL=lifecycle-command.js.map

package/dist/executors/lifecycle/index.cjs

@@ -9,5 +9,7 @@ Object.defineProperty(exports, "default", {
     }
 });
 const _commonproxy = require("common-proxy");
-const _default = (0, _commonproxy.commonProxy)(import('./index.js'));
-//# sourceMappingURL=index.cjs.map
+const _nxpluginhandler = require("nx-plugin-handler");
+const _default = (0, _nxpluginhandler.handler)((0, _commonproxy.commonProxy)(import('./index.js')));
+
+//# sourceMappingURL=index.cjs.map

package/dist/executors/lifecycle/index.d.cts

@@ -1,4 +1,5 @@
-declare const _default: (options: Partial<{
+declare const _default: import("nx-plugin-handler").RawHandler<(Partial<{
+    $schema: string;
     check: boolean;
     dryRun: boolean;
     stages: Record<string, Partial<{
@@ -42,8 +43,57 @@ declare const _default: (options: Partial<{
         hooks: string[];
     }>>;
     bindings: Record<string, string>;
-}>, context: import("@nx/devkit").ExecutorContext) => Promise<{
-    success: boolean;
-}>;
+}> & Required<Pick<{
+    $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<{
+            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))[];
+        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

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

@@ -1,47 +1,5 @@
-declare const _default: import("nx-plugin-handler").RawHandler<Partial<{
-    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<{
-            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))[];
-        hooks: string[];
-    }>>;
-    bindings: Record<string, string>;
-}>>;
+declare const _default: (options: import("../../lifecycle/schema.js").LifecycleOptionsOrConfig, context: import("./lifecycle.js").SimpleExecutorContext) => Promise<{
+    success: boolean;
+}>;
 export default _default;
 //# sourceMappingURL=index.d.ts.map

package/dist/executors/lifecycle/index.js

@@ -1,22 +1,10 @@
-import { bind, createContainer, createModule } from 'haywire';
-import { handler } from 'nx-plugin-handler';
-import { isNxJson, isNxJsonIdentifier, isProjectJson, isProjectJsonIdentifier } from '#schemas';
-import { dependenciesModule, formatFileIdentifier, isCiIdentifier, loggerIdentifier, readFileIdentifier, writeFileIdentifier } from './depedencies.js';
+import { bind, createContainer } from 'haywire';
+import { lifecycleInternalId, lifecycleInternalModule } from '../../lifecycle/index.js';
 import { Lifecycle } from './lifecycle.js';
-import { Normalizer } from './normalizer.js';
-import { nxAndProjectJsonProcessorIdentifier, processNxAndProjectJsons } from './processor.js';
-const pluginModule = createModule(bind(Lifecycle).withConstructorProvider().withDependencies([
-    Normalizer,
-    readFileIdentifier,
-    writeFileIdentifier,
-    formatFileIdentifier,
-    nxAndProjectJsonProcessorIdentifier,
-    isNxJsonIdentifier,
-    isProjectJsonIdentifier,
-    loggerIdentifier
-])).addBinding(bind(Normalizer).withConstructorProvider().withDependencies([
-    isCiIdentifier
-])).addBinding(bind(nxAndProjectJsonProcessorIdentifier).withInstance(processNxAndProjectJsons)).addBinding(bind(isNxJsonIdentifier).withInstance(isNxJson)).addBinding(bind(isProjectJsonIdentifier).withInstance(isProjectJson));
-const lifecycle = createContainer(dependenciesModule.mergeModule(pluginModule)).get(Lifecycle);
-export default handler(lifecycle.lifecycle.bind(lifecycle));
-//# sourceMappingURL=index.js.map
+const lifecycleModule = lifecycleInternalModule.addBinding(bind(Lifecycle).withDependencies([
+    lifecycleInternalId
+]).withConstructorProvider());
+const lifecycle = createContainer(lifecycleModule).get(Lifecycle);
+export default lifecycle.lifecycle;
+
+//# sourceMappingURL=index.js.map

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

@@ -1,11 +1,7 @@
-import type * as fs from 'node:fs/promises';
-import type { FilesFormatter } from 'format-file';
-import type { IsNxJson, IsProjectJson } from '#schemas';
-import type { Logger } from './depedencies.js';
-import type { Normalizer } from './normalizer.js';
-import type { NxAndProjectJsonProcessor } from './processor.js';
-import type { LifecycleOptions } from './schema.js';
-import type { SimpleExecutorContext } from './types.js';
+import type { ExecutorContext } from '@nx/devkit';
+import type { ILifecycleInternal } from '../../lifecycle/lifecycle-internal.js';
+import type { LifecycleOptionsOrConfig } from '../../lifecycle/schema.js';
+export type SimpleExecutorContext = Pick<ExecutorContext, 'projectsConfigurations' | 'root'>;
 /**
  * Main logic for lifecycle file management.
  *
@@ -15,9 +11,9 @@ import type { SimpleExecutorContext } from './types.js';
  */
 export declare class Lifecycle {
     #private;
-    constructor(normalizer: Normalizer, readFile: (typeof fs)['readFile'], writeFile: (typeof fs)['writeFile'], formatFiles: FilesFormatter, processNxAndProjectJsons: NxAndProjectJsonProcessor, isNxJson: IsNxJson, isProjectJson: IsProjectJson, logger: Logger);
-    lifecycle(options: LifecycleOptions, context: SimpleExecutorContext): Promise<{
+    readonly lifecycle: (options: LifecycleOptionsOrConfig, context: SimpleExecutorContext) => Promise<{
         success: boolean;
     }>;
+    constructor(lifecycleInternal: ILifecycleInternal);
 }
 //# sourceMappingURL=lifecycle.d.ts.map