refactor: use mainsail for process names (#431)

* Remove token from process

* Add contracts

* Use contracts

* Use app name

* Remove token flag

* Remove token flag from api commands

* Fix core tests

* Fix api commands

* Fix tests

packages/api/source/commands/api-log.ts

@@ -1,4 +1,4 @@
-import { Commands, Identifiers } from "@mainsail/cli";
+import { Commands, Contracts, Identifiers } from "@mainsail/cli";
 import { injectable } from "@mainsail/container";
 import Joi from "joi";
 
@@ -10,14 +10,13 @@ export class Command extends Commands.Command {
 
 	public configure(): void {
 		this.definition
-			.setFlag("token", "The name of the token.", Joi.string())
 			.setFlag("error", "Only display the error output.", Joi.boolean())
 			.setFlag("lines", "The number of lines to output.", Joi.number().default(15));
 	}
 
 	public async execute(): Promise<void> {
 		await this.app
-			.get<any>(Identifiers.ProcessFactory)(this.getFlag("token"), "api")
+			.get<Contracts.ProcessFactory>(Identifiers.ProcessFactory)("mainsail-api")
 			.log(this.getFlag("error"), this.getFlag("lines"));
 	}
 }

packages/api/source/commands/api-restart.test.ts

@@ -16,14 +16,14 @@ describe<{
 		const missing = stub(processManager, "missing").returnValue(true);
 		const isStopped = stub(processManager, "isStopped").returnValue(false);
 
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process does not exist.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process does not exist.');
 	});
 
 	it("should throw if the process is stopped", async ({ processManager, cli }) => {
 		const missing = stub(processManager, "missing").returnValue(false);
 		const isStopped = stub(processManager, "isStopped").returnValue(true);
 
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process is not running.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process is not running.');
 	});
 
 	it("should restart the process", async ({ processManager, cli }) => {

packages/api/source/commands/api-restart.ts

@@ -1,18 +1,13 @@
-import { Commands, Identifiers } from "@mainsail/cli";
+import { Commands, Contracts, Identifiers } from "@mainsail/cli";
 import { injectable } from "@mainsail/container";
-import Joi from "joi";
 
 @injectable()
 export class Command extends Commands.Command {
 	public signature = "api:restart";
 
 	public description = "Restart the API process.";
 
-	public configure(): void {
-		this.definition.setFlag("token", "The name of the token.", Joi.string().required());
-	}
-
 	public async execute(): Promise<void> {
-		this.app.get<any>(Identifiers.ProcessFactory)(this.getFlag("token"), "api").restart();
+		this.app.get<Contracts.ProcessFactory>(Identifiers.ProcessFactory)("mainsail-api").restart();
 	}
 }

packages/api/source/commands/api-start.test.ts

@@ -30,11 +30,11 @@ describe<{
 					CORE_ENV: "production",
 					NODE_ENV: "production",
 				},
-				name: "ark-api",
+				name: "mainsail-api",
 				node_args: undefined,
 				script: resolve(__dirname, "../../../../packages/api/bin/run"),
 			},
-			{ "kill-timeout": 30_000, "max-restarts": 5, name: "ark-api" },
+			{ "kill-timeout": 30_000, "max-restarts": 5, name: "mainsail-api" },
 		);
 	});
 });

packages/api/source/commands/api-start.ts

@@ -26,7 +26,7 @@ export class Command extends Commands.Command {
 		await this.actions.daemonizeProcess(
 			{
 				args: `core:run ${Utils.Flags.castFlagsToString(flags, ["daemon"])}`,
-				name: `${flags.token}-api`,
+				name: `mainsail-api`,
 				script: resolve(__dirname, "../../bin/run"),
 			},
 			flags,

packages/api/source/commands/api-status.test.ts

@@ -13,14 +13,14 @@ describe<{
 	});
 
 	it("should throw if the process does not exist", async ({ cli }) => {
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process does not exist.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process does not exist.');
 	});
 
 	it("should render a table with the process information", async ({ processManager, cli }) => {
 		stub(processManager, "missing").returnValue(false);
 		stub(processManager, "describe").returnValue({
 			monit: { cpu: 2, memory: 2048 },
-			name: "ark-api",
+			name: "mainsail-api",
 			pid: 1,
 			pm2_env: {
 				pm_uptime: 1_387_045_673_686,
@@ -40,7 +40,7 @@ describe<{
 		assert.true(
 			[
 				"1",
-				"ark-api",
+				"mainsail-api",
 				"1.0.0",
 				"online",
 				// "5y 267d 19h 31m 28.1s",

packages/api/source/commands/api-status.ts

@@ -1,18 +1,13 @@
-import { Commands, Identifiers } from "@mainsail/cli";
+import { Commands, Contracts, Identifiers } from "@mainsail/cli";
 import { injectable } from "@mainsail/container";
-import Joi from "joi";
 
 @injectable()
 export class Command extends Commands.Command {
 	public signature = "api:status";
 
 	public description = "Display the status of the API process.";
 
-	public configure(): void {
-		this.definition.setFlag("token", "The name of the token.", Joi.string());
-	}
-
 	public async execute(): Promise<void> {
-		this.app.get<any>(Identifiers.ProcessFactory)(this.getFlag("token"), "api").status();
+		this.app.get<Contracts.ProcessFactory>(Identifiers.ProcessFactory)("mainsail-api").status();
 	}
 }

packages/api/source/commands/api-stop.test.ts

@@ -17,23 +17,23 @@ describe<{
 		const isUnknown = stub(processManager, "isUnknown").returnValue(false);
 		const isStopped = stub(processManager, "isStopped").returnValue(false);
 
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process does not exist.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process does not exist.');
 	});
 
 	it("should throw if the process entered an unknown state", async ({ processManager, cli }) => {
 		const missing = stub(processManager, "missing").returnValue(false);
 		const isUnknown = stub(processManager, "isUnknown").returnValue(true);
 		const isStopped = stub(processManager, "isStopped").returnValue(false);
 
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process has entered an unknown state.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process has entered an unknown state.');
 	});
 
 	it("should throw if the process is stopped", async ({ processManager, cli }) => {
 		const missing = stub(processManager, "missing").returnValue(false);
 		const isUnknown = stub(processManager, "isUnknown").returnValue(false);
 		const isStopped = stub(processManager, "isStopped").returnValue(true);
 
-		await assert.rejects(() => cli.execute(Command), 'The "ark-api" process is not running.');
+		await assert.rejects(() => cli.execute(Command), 'The "mainsail-api" process is not running.');
 	});
 
 	it("should stop the process if the [--daemon] flag is not present", async ({ processManager, cli }) => {

packages/api/source/commands/api-stop.ts

@@ -1,4 +1,4 @@
-import { Commands, Identifiers } from "@mainsail/cli";
+import { Commands, Contracts, Identifiers } from "@mainsail/cli";
 import { injectable } from "@mainsail/container";
 import Joi from "joi";
 
@@ -9,12 +9,10 @@ export class Command extends Commands.Command {
 	public description = "Stop the API process.";
 
 	public configure(): void {
-		this.definition
-			.setFlag("token", "The name of the token.", Joi.string())
-			.setFlag("daemon", "Stop the Core process or daemon.", Joi.boolean());
+		this.definition.setFlag("daemon", "Stop the Core process or daemon.", Joi.boolean());
 	}
 
 	public async execute(): Promise<void> {
-		this.app.get<any>(Identifiers.ProcessFactory)(this.getFlag("token"), "api").stop(this.getFlag("daemon"));
+		this.app.get<Contracts.ProcessFactory>(Identifiers.ProcessFactory)("mainsail-api").stop(this.getFlag("daemon"));
 	}
 }

packages/cli/source/application-factory.ts

@@ -73,15 +73,12 @@ export class ApplicationFactory {
 
 		app.bind(Identifiers.ComponentFactory).to(ComponentFactory).inSingletonScope();
 
-		app.bind(Identifiers.ProcessFactory).toFactory(
-			(context: interfaces.Context) =>
-				(token: string, type: string): Process => {
-					const process: Process = context.container.resolve(Process);
-					process.initialize(token, type);
-
-					return process;
-				},
-		);
+		app.bind(Identifiers.ProcessFactory).toFactory((context: interfaces.Context) => (type: string): Process => {
+			const process: Process = context.container.resolve(Process);
+			process.initialize(type);
+
+			return process;
+		});
 
 		// Services
 		app.bind(Identifiers.Output).to(Output).inSingletonScope();

packages/cli/source/contracts.ts

@@ -87,6 +87,15 @@ export type ProcessDescription = Record<string, any>;
 
 export type ProcessOptions = Record<"name" | "script" | "args", string>;
 
+export interface Process {
+	stop(daemon: boolean): void;
+	restart(): void;
+	status(): void;
+	log(showErrors: boolean, lines: number): void;
+}
+
+export type ProcessFactory = (name: string) => Process;
+
 // APPLICATION
 export interface Application {
 	bind<T>(serviceIdentifier: interfaces.ServiceIdentifier<T>): interfaces.BindingToSyntax<T>;

packages/cli/source/utils/process.test.ts

@@ -24,7 +24,7 @@ describe<{
 				return process;
 			});
 
-		context.process = context.cli.app.get(Identifiers.ProcessFactory)("ark", "core");
+		context.process = context.cli.app.get(Identifiers.ProcessFactory)("mainsail");
 	});
 
 	afterAll(() => setGracefulCleanup());
@@ -34,23 +34,23 @@ describe<{
 		stub(processManager, "isUnknown").returnValue(false);
 		stub(processManager, "isStopped").returnValue(false);
 
-		assert.throws(() => process.stop(false), 'The "ark-core" process does not exist.');
+		assert.throws(() => process.stop(false), 'The "mainsail" process does not exist.');
 	});
 
 	it("#stop - should throw if the process entered an unknown state", ({ process, processManager }) => {
 		stub(processManager, "missing").returnValue(false);
 		stub(processManager, "isUnknown").returnValue(true);
 		stub(processManager, "isStopped").returnValue(false);
 
-		assert.throws(() => process.stop(false), 'The "ark-core" process has entered an unknown state.');
+		assert.throws(() => process.stop(false), 'The "mainsail" process has entered an unknown state.');
 	});
 
 	it("#stop - should throw if the process is stopped", ({ process, processManager }) => {
 		stub(processManager, "missing").returnValue(false);
 		stub(processManager, "isUnknown").returnValue(false);
 		stub(processManager, "isStopped").returnValue(true);
 
-		assert.throws(() => process.stop(false), 'The "ark-core" process is not running.');
+		assert.throws(() => process.stop(false), 'The "mainsail" process is not running.');
 	});
 
 	it("#stop - should delete the process if the [--daemon] flag is not present", ({ process, processManager }) => {
@@ -79,14 +79,14 @@ describe<{
 		stub(processManager, "missing").returnValue(true);
 		stub(processManager, "isStopped").returnValue(false);
 
-		assert.throws(() => process.restart(), 'The "ark-core" process does not exist.');
+		assert.throws(() => process.restart(), 'The "mainsail" process does not exist.');
 	});
 
 	it("#restart - should throw if the process is stopped", ({ process, processManager }) => {
 		stub(processManager, "missing").returnValue(false);
 		stub(processManager, "isStopped").returnValue(true);
 
-		assert.throws(() => process.restart(), 'The "ark-core" process is not running.');
+		assert.throws(() => process.restart(), 'The "mainsail" process is not running.');
 	});
 
 	it("#restart - should restart the process", ({ process, processManager }) => {
@@ -100,14 +100,14 @@ describe<{
 	});
 
 	it("#status - should throw if the process does not exist", async ({ process }) => {
-		assert.throws(() => process.status(), 'The "ark-core" process does not exist.');
+		assert.throws(() => process.status(), 'The "mainsail" process does not exist.');
 	});
 
 	it("#status - should render a table with the process information", async ({ process, processManager }) => {
 		stub(processManager, "missing").returnValue(false);
 		stub(processManager, "describe").returnValue({
 			monit: { cpu: 2, memory: 2048 },
-			name: "ark-core",
+			name: "mainsail",
 			pid: 1,
 			pm2_env: {
 				pm_uptime: 1_387_045_673_686,
@@ -128,7 +128,7 @@ describe<{
 		assert.true(
 			[
 				"1",
-				"ark-core",
+				"mainsail",
 				"1.0.0",
 				"online",
 				// "5y 267d 19h 31m 28.1s",
@@ -139,14 +139,14 @@ describe<{
 	});
 
 	it("#log - should throw if the process does not exist", async ({ process }) => {
-		await assert.rejects(() => process.log(false, 1), 'The "ark-core" process does not exist.');
+		await assert.rejects(() => process.log(false, 1), 'The "mainsail" process does not exist.');
 	});
 
 	it("#log - should log to pm_out_log_path", async ({ cli, process, processManager }) => {
 		stub(cli.app.get(Identifiers.AbortMissingProcess), "execute");
 		stub(processManager, "describe").returnValue({
 			monit: { cpu: 2, memory: 2048 },
-			name: "ark-core",
+			name: "mainsail",
 			pid: 1,
 			pm2_env: {
 				pm_err_log_path: fileSync().name,
@@ -162,14 +162,14 @@ describe<{
 		await process.log(false, 15);
 
 		spyWatch.calledOnce();
-		spyLog.calledWith("Tailing last 15 lines for [ark-core] process (change the value with --lines option)");
+		spyLog.calledWith("Tailing last 15 lines for [mainsail] process (change the value with --lines option)");
 	});
 
 	it("#log - should log to pm_err_log_path", async ({ cli, process, processManager }) => {
 		stub(cli.app.get(Identifiers.AbortMissingProcess), "execute");
 		stub(processManager, "describe").returnValue({
 			monit: { cpu: 2, memory: 2048 },
-			name: "ark-core",
+			name: "mainsail",
 			pid: 1,
 			pm2_env: {
 				pm_err_log_path: fileSync().name,
@@ -185,6 +185,6 @@ describe<{
 		await process.log(true, 15);
 
 		spyWatch.calledOnce();
-		spyLog.calledWith("Tailing last 15 lines for [ark-core] process (change the value with --lines option)");
+		spyLog.calledWith("Tailing last 15 lines for [mainsail] process (change the value with --lines option)");
 	});
 });

packages/cli/source/utils/process.ts

@@ -8,12 +8,12 @@ import readLastLines from "read-last-lines";
 import type { AbortMissingProcess, AbortStoppedProcess, AbortUnknownProcess } from "../actions";
 import { Application } from "../application";
 import { Clear, Spinner, Table } from "../components";
-import { ProcessDescription } from "../contracts";
+import { Process as IProcess, ProcessDescription } from "../contracts";
 import { Identifiers } from "../ioc";
 import type { ProcessManager } from "../services";
 
 @injectable()
-export class Process {
+export class Process implements IProcess {
 	@inject(Identifiers.Application.Instance)
 	private readonly app!: Application;
 
@@ -22,8 +22,8 @@ export class Process {
 
 	#processName!: string;
 
-	public initialize(token: string, suffix: string): void {
-		this.#processName = `${token}-${suffix}`;
+	public initialize(processName: string): void {
+		this.#processName = processName;
 	}
 
 	public stop(daemon: boolean): void {

packages/core/source/commands/core-log.ts

@@ -1,4 +1,4 @@
-import { Commands, Identifiers } from "@mainsail/cli";
+import { Commands, Contracts, Identifiers } from "@mainsail/cli";
 import { injectable } from "@mainsail/container";
 import Joi from "joi";
 
@@ -10,14 +10,13 @@ export class Command extends Commands.Command {
 
 	public configure(): void {
 		this.definition
-			.setFlag("token", "The name of the token.", Joi.string().required())
 			.setFlag("error", "Only display the error output.", Joi.boolean())
 			.setFlag("lines", "The number of lines to output.", Joi.number().default(15));
 	}
 
 	public async execute(): Promise<void> {
 		await this.app
-			.get<any>(Identifiers.ProcessFactory)(this.getFlag("token"), "core")
+			.get<Contracts.ProcessFactory>(Identifiers.ProcessFactory)("mainsail")
 			.log(this.getFlag("error"), this.getFlag("lines"));
 	}
 }