@cenk1cenk2/oclif-common 6.3.29 → 6.4.0

package/dist/commands/base.command.d.ts

@@ -0,0 +1,43 @@
+import { PipeProcessToLoggerOptions } from "../lib/logger/pipe/pipe-process-to-logger.interface.js";
+import { LoggerService } from "../lib/logger/logger.service.js";
+import { SetCtxAssignOptions, SetCtxDefaultsOptions } from "../utils/defaults.js";
+import { InferArgs, InferFlags } from "../interfaces/oclif.interface.js";
+import { INestApplicationContext } from "@nestjs/common";
+import { Manager } from "@listr2/manager";
+import { Command } from "@oclif/core";
+import { ListrContext, ListrTaskWrapper } from "listr2";
+import "reflect-metadata";
+import * as _oclif_core_lib_interfaces0 from "@oclif/core/lib/interfaces";
+import { ChildProcess } from "child_process";
+
+//#region src/commands/base.command.d.ts
+declare abstract class Command$1<T extends typeof Command = typeof Command, Ctx extends ListrContext = ListrContext> extends Command {
+  static baseFlags: {
+    "log-level": _oclif_core_lib_interfaces0.OptionFlag<string, _oclif_core_lib_interfaces0.CustomOptions>;
+    ci: _oclif_core_lib_interfaces0.BooleanFlag<boolean>;
+    json: _oclif_core_lib_interfaces0.BooleanFlag<boolean>;
+  };
+  logger: LoggerService;
+  tasks: Manager<Ctx>;
+  app: INestApplicationContext;
+  flags: InferFlags<T>;
+  args: InferArgs<T>;
+  exit(code?: number): never;
+  /** Run all tasks from task manager. */
+  runTasks<C extends Ctx = Ctx>(): Promise<C>;
+  protected setCtxDefaults<T extends Ctx = Ctx>(...defaults: SetCtxDefaultsOptions<T>[]): void;
+  protected setCtxAssign<K = Record<PropertyKey, any>>(...assigns: SetCtxAssignOptions<K>[]): void;
+  protected pipeProcessToLogger(instance: ChildProcess, options?: PipeProcessToLoggerOptions): ChildProcess;
+  protected pipeProcessThroughListr(instance: ChildProcess, task: ListrTaskWrapper<any, any, any>): ChildProcess;
+  /** Initial functions / constructor */
+  protected init(): Promise<void>;
+  /** Tasks to run before end of the command. */
+  protected finally<C extends Ctx = Ctx>(err: Error | undefined): Promise<{
+    ctx: C;
+  }>;
+  /** Catch any error occurred during command. */
+  protected catch(err: Error): Promise<never>;
+  abstract run(): Promise<any>;
+}
+//#endregion
+export { Command$1 as Command };

package/dist/commands/base.command.js

@@ -0,0 +1,156 @@
+import { HelpGroups } from "../constants/help-groups.constants.js";
+import { pipeProcessThroughListr } from "../lib/logger/pipe/pipe-process-to-listr.js";
+import { LogFieldStatus, LogLevels } from "../lib/logger/logger.constants.js";
+import { pipeProcessToLogger } from "../lib/logger/pipe/pipe-process-to-logger.js";
+import { LoggerService } from "../lib/logger/logger.service.js";
+import { setCtxAssign, setCtxDefaults } from "../utils/defaults.js";
+import { isHookedWithRegister, isHookedWithShouldRunAfter, isHookedWithShouldRunBefore } from "../utils/guards.js";
+import "../utils/index.js";
+import { ConfigService } from "../lib/config/config.service.js";
+import { LogoService } from "../lib/logo/logo.service.js";
+import { CliModule } from "../lib/cli.module.js";
+import "../lib/index.js";
+import { Manager } from "@listr2/manager";
+import { Command, Flags } from "@oclif/core";
+import { createInterface } from "readline";
+import "reflect-metadata";
+
+//#region src/commands/base.command.ts
+var Command$1 = class extends Command {
+	static {
+		this.baseFlags = {
+			["log-level"]: Flags.string({
+				default: LogLevels.INFO,
+				env: "LOG_LEVEL",
+				description: "Set the log level of the application.",
+				options: Object.values(LogLevels).map((level) => level.toLowerCase()),
+				helpGroup: HelpGroups.CLI,
+				parse: async (input) => input?.toUpperCase()
+			}),
+			ci: Flags.boolean({
+				default: false,
+				hidden: true,
+				env: "CI",
+				description: "Instruct whether this is running the CI/CD configuration.",
+				helpGroup: HelpGroups.CLI
+			}),
+			json: Flags.boolean({
+				default: false,
+				hidden: true,
+				env: "JSON",
+				description: "Put the CLI to respond in JSON.",
+				helpGroup: HelpGroups.CLI
+			})
+		};
+	}
+	exit(code) {
+		this.logger.trace("Code -> %d", code, { status: LogFieldStatus.EXIT });
+		super.exit(code ?? 0);
+	}
+	/** Run all tasks from task manager. */
+	runTasks() {
+		return this.tasks.runAll();
+	}
+	setCtxDefaults(...defaults) {
+		setCtxDefaults(this.tasks.options.ctx, ...defaults);
+		this.logger.trace("Updated context with defaults: %o", this.tasks.options.ctx, { status: "ctx" });
+	}
+	setCtxAssign(...assigns) {
+		setCtxAssign(this.tasks.options.ctx, ...assigns);
+		this.logger.trace("Updated context with assign: %o", this.tasks.options.ctx, { status: "ctx" });
+	}
+	pipeProcessToLogger(instance, options) {
+		return pipeProcessToLogger(this.logger, instance, options);
+	}
+	pipeProcessThroughListr(instance, task) {
+		return pipeProcessThroughListr(task, instance);
+	}
+	/** Initial functions / constructor */
+	async init() {
+		await super.init();
+		let err;
+		try {
+			const { args, flags } = await this.parse({
+				flags: this.ctor.flags,
+				baseFlags: super.ctor.baseFlags,
+				enableJsonFlag: this.ctor.enableJsonFlag,
+				args: this.ctor.args,
+				strict: this.ctor.strict
+			});
+			this.flags = flags;
+			this.args = args;
+		} catch (e) {
+			err = e;
+		}
+		const options = { config: {
+			oclif: this.config,
+			command: this.ctor,
+			config: {
+				logLevel: this.flags?.["log-level"] ?? LogLevels.INFO,
+				isJson: this.flags?.json ?? false
+			}
+		} };
+		const cli = CliModule.forRoot(options);
+		this.app = await CliModule.create(!err && isHookedWithRegister(this) ? await this.register(cli, options) : cli);
+		await this.app.init();
+		const cs = this.app.get(ConfigService);
+		this.logger = await this.app.resolve(LoggerService);
+		this.app.useLogger(this.logger);
+		this.app.get(LogoService).generate();
+		if (err) throw err;
+		this.logger.stage("Created application context.");
+		this.tasks = new Manager({
+			fallbackRendererCondition: cs.isDebug,
+			silentRendererCondition: cs.isSilent || cs.isJson,
+			ctx: {}
+		});
+		if (cs.oclif.windows) createInterface({
+			input: process.stdin,
+			output: process.stdout
+		}).on("SIGINT", () => {
+			process.kill(process.pid, "SIGINT");
+		});
+		const terminate = () => {
+			this.logger.fatal("Caught terminate signal.", { status: LogFieldStatus.TERMINATE });
+			process.exit(1);
+		};
+		process.on("SIGINT", terminate);
+		process.on("SIGTERM", terminate);
+		if (isHookedWithShouldRunBefore(this)) {
+			this.logger.stage("Running hook should-run-before.");
+			await this.shouldRunBefore();
+			this.logger.stage("Finished hook should-run-before.");
+		}
+	}
+	/** Tasks to run before end of the command. */
+	async finally(err) {
+		let ctx;
+		if (err) return { ctx };
+		if (this.tasks?.tasks?.length > 0) {
+			this.logger.stage("Running tasks.");
+			ctx = await this.runTasks();
+			this.logger.stage("Finished tasks.");
+		}
+		if (isHookedWithShouldRunAfter(this)) {
+			this.logger.stage("Running hook should-run-after.");
+			await this.shouldRunAfter(ctx);
+			this.logger.stage("Finished hook should-run-after.");
+		}
+		await this.app.close();
+		return { ctx };
+	}
+	/** Catch any error occurred during command. */
+	async catch(err) {
+		process.exitCode = process.exitCode ?? err.exitCode ?? 1;
+		if (!this.logger) {
+			this.app = await CliModule.create(CliModule.forMinimum());
+			this.logger = await this.app.resolve(LoggerService);
+		}
+		this.logger.fatal(err.message);
+		this.logger.debug(err.stack, { context: "crash" });
+		throw err;
+	}
+};
+
+//#endregion
+export { Command$1 as Command };

package/dist/commands/index.js

@@ -0,0 +1 @@
+import { Command } from "./base.command.js";

package/dist/constants/file.constants.d.ts

@@ -0,0 +1,6 @@
+//#region src/constants/file.constants.d.ts
+declare enum FileConstants {
+  CONFIG_SERVICE_DEFAULTS_DIR = "config",
+}
+//#endregion
+export { FileConstants };

package/dist/constants/file.constants.js

@@ -0,0 +1,8 @@
+//#region src/constants/file.constants.ts
+let FileConstants = /* @__PURE__ */ function(FileConstants$1) {
+	FileConstants$1["CONFIG_SERVICE_DEFAULTS_DIR"] = "config";
+	return FileConstants$1;
+}({});
+
+//#endregion
+export { FileConstants };

package/dist/constants/help-groups.constants.d.ts

@@ -0,0 +1,6 @@
+//#region src/constants/help-groups.constants.d.ts
+declare enum HelpGroups {
+  CLI = "CLI",
+}
+//#endregion
+export { HelpGroups };

package/dist/constants/help-groups.constants.js

@@ -0,0 +1,8 @@
+//#region src/constants/help-groups.constants.ts
+let HelpGroups = /* @__PURE__ */ function(HelpGroups$1) {
+	HelpGroups$1["CLI"] = "CLI";
+	return HelpGroups$1;
+}({});
+
+//#endregion
+export { HelpGroups };

package/dist/hooks/index.js

@@ -0,0 +1,2 @@
+import { notFoundHook } from "./not-found.hook.js";
+import { updateNotifierHook } from "./update-notifier.hook.js";

package/dist/hooks/not-found.hook.d.ts

@@ -0,0 +1,6 @@
+import { Hook } from "@oclif/core";
+
+//#region src/hooks/not-found.hook.d.ts
+declare const notFoundHook: Hook<'command_not_found'>;
+//#endregion
+export { notFoundHook };

package/dist/hooks/not-found.hook.js

@@ -0,0 +1,18 @@
+import { LoggerService } from "../lib/logger/logger.service.js";
+import { CliModule } from "../lib/cli.module.js";
+import "../lib/index.js";
+import { Help } from "@oclif/core";
+
+//#region src/hooks/not-found.hook.ts
+const notFoundHook = async (opts) => {
+	const app = await CliModule.create(CliModule.forMinimum());
+	const logger = await app.resolve(LoggerService);
+	logger.error("Command not found. Take a look at help. You can also use --[h]elp flag for subcommands.");
+	logger.direct("");
+	const help = new Help(opts.config);
+	await help.showHelp(["--all"]);
+	opts.context.exit(127);
+};
+
+//#endregion
+export { notFoundHook };

package/dist/hooks/update-notifier.hook.d.ts

@@ -0,0 +1,6 @@
+import { Hook } from "@oclif/core";
+
+//#region src/hooks/update-notifier.hook.d.ts
+declare const updateNotifierHook: Hook<'init'>;
+//#endregion
+export { updateNotifierHook };

package/dist/hooks/update-notifier.hook.js

@@ -0,0 +1,11 @@
+//#region src/hooks/update-notifier.hook.ts
+const updateNotifierHook = async (opts) => {
+	const { default: notifier } = await import("update-notifier");
+	notifier({ pkg: {
+		name: opts.config.name,
+		version: opts.config.version
+	} }).notify({ isGlobal: true });
+};
+
+//#endregion
+export { updateNotifierHook };