biaws 0.1.0

package/src/commands/demands/list.js

@@ -0,0 +1,48 @@
+import { Flags } from "@oclif/core";
+import {
+  connectionFlags,
+  listFlags,
+  ReadCommand,
+} from "../../domain/readCommand.js";
+import { table } from "../../domain/readService.js";
+export default class DemandList extends ReadCommand {
+  static description = "Lista melhorias no escopo informado";
+  static flags = {
+    ...connectionFlags,
+    ...listFlags,
+    application: Flags.string({ description: "ID da aplicação" }),
+    component: Flags.string({ description: "ID do componente" }),
+  };
+  async run() {
+    const { flags } = await this.parse(DemandList);
+    const result = await this.read(
+      flags,
+      (api, c) =>
+        api.demands({
+          workspaceId: c.workspaceId,
+          applicationId: flags.application,
+          componentId: flags.component,
+          status: flags.status,
+          text: flags.search,
+          page: flags.page,
+          limit: flags.limit,
+        }),
+      {
+        resource: "demands",
+        operation: "list",
+        requireWorkspace: true,
+        scope: (c) => ({
+          workspaceId: c.workspaceId,
+          applicationId: flags.application,
+        }),
+      },
+    );
+    this.emit(flags, result, (p) =>
+      table(p.items || [], [
+        ["CÓDIGO", (x) => x.clientCode || x.id],
+        ["TÍTULO", (x) => x.title],
+        ["STATUS", (x) => x.status],
+      ]),
+    );
+  }
+}

package/src/commands/demands/task-status.js

@@ -0,0 +1,49 @@
+import { Args, Flags } from "@oclif/core";
+import { WriteCommand, writeFlags } from "../../domain/writeCommand.js";
+import { findTask } from "../../domain/writeService.js";
+
+export default class DemandTaskStatus extends WriteCommand {
+  static description = "Altera o status de uma tarefa por ação específica";
+  static args = {
+    demand: Args.string({ required: true }),
+    task: Args.string({ required: true }),
+  };
+  static flags = {
+    ...writeFlags,
+    status: Flags.string({ description: "novo status" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(DemandTaskStatus);
+    const status = flags.status || this.constructor.defaultStatus;
+    if (!status) {
+      this.error("Informe --status para alterar a tarefa.", {
+        code: "MISSING_STATUS",
+        exit: 2,
+      });
+    }
+    return this.write(
+      flags,
+      "task",
+      async (service) => {
+        const { request, task } = findTask(
+          await service.demand(args.demand),
+          args.task,
+        );
+        return {
+          resource: "task",
+          operation: "status.update",
+          requestId: request.id || args.demand,
+          applicationId: request.applicationId || task.applicationId || null,
+          taskId: task.id || task._id || task.code,
+          currentStatus: task.status,
+          status,
+          label: `Tarefa ${task.code || task.id || task._id}`,
+          entity: task,
+        };
+      },
+      (service, plan) =>
+        service.updateTaskStatus(plan.requestId, plan.taskId, plan.status),
+    );
+  }
+}

package/src/commands/demands/tasks.js

@@ -0,0 +1,44 @@
+import { Args, Flags } from "@oclif/core";
+import { connectionFlags, ReadCommand } from "../../domain/readCommand.js";
+import { readEnvelope, table } from "../../domain/readService.js";
+export default class DemandTasks extends ReadCommand {
+  static description = "Lista tarefas de uma melhoria";
+  static args = { demand: Args.string({ required: true }) };
+  static flags = {
+    ...connectionFlags,
+    status: Flags.string({ description: "filtra por status" }),
+  };
+  async run() {
+    const { args, flags } = await this.parse(DemandTasks);
+    const result = await this.read(
+      flags,
+      async (api, c) => {
+        const payload = await api.demand(args.demand, {
+          workspaceId: c.workspaceId,
+        });
+        const request = payload.request || payload;
+        const items = (request.tasks || []).filter(
+          (x) => !flags.status || x.status === flags.status,
+        );
+        return { items, meta: { total: items.length } };
+      },
+      {
+        resource: "tasks",
+        operation: "list",
+        requireWorkspace: true,
+        scope: (c) => ({ workspaceId: c.workspaceId, requestId: args.demand }),
+      },
+    );
+    result.envelope = readEnvelope("tasks", "list", result.payload, {
+      workspaceId: result.context.workspaceId,
+      requestId: args.demand,
+    });
+    this.emit(flags, result, (p) =>
+      table(p.items, [
+        ["CÓDIGO", (x) => x.code || x.id],
+        ["TÍTULO", (x) => x.title],
+        ["STATUS", (x) => x.status],
+      ]),
+    );
+  }
+}

package/src/commands/demands.js

@@ -0,0 +1,7 @@
+import { Command } from "@oclif/core";
+export default class Demands extends Command {
+  static description = "Consulta melhorias e suas tarefas pela API";
+  async run() {
+    await this.config.runCommand("help", ["demands"]);
+  }
+}

package/src/commands/instance/backup.js

@@ -0,0 +1,74 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+} from "../../instance/command.js";
+import {
+  backupArguments,
+  executeInstanceScript,
+  getInstance,
+  withPasswordFile,
+} from "../../instance/service.js";
+
+export default class InstanceBackup extends LocalInstanceCommand {
+  static description =
+    "cria backup completo, criptografado e verificável de uma instância";
+  static args = { instance: instanceArgument };
+  static flags = {
+    ...contextFlags,
+    output: Flags.string({
+      char: "o",
+      description: "arquivo de backup de destino",
+    }),
+    "password-file": Flags.string({
+      description: "arquivo privado contendo a senha",
+    }),
+    json: Flags.boolean({ description: "emite resultado JSON" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceBackup);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    let password;
+    if (!flags["password-file"]) {
+      if (!context.isInteractive)
+        this.error("Informe --password-file em modo não interativo.", {
+          code: "BACKUP_PASSWORD_REQUIRED",
+          exit: 2,
+        });
+      password = await this.adapters.prompts.ask({
+        name: "password",
+        type: "password",
+        message: "Senha do backup",
+      });
+    }
+    const output = await withPasswordFile(
+      this.adapters.filesystem,
+      password,
+      flags["password-file"],
+      async (passwordFile) =>
+        executeInstanceScript(
+          backupArguments(instance, context, {
+            output: flags.output,
+            passwordFile,
+          }),
+          context,
+          this.adapters.processRunner,
+          { secrets: password ? [password] : [], silent: flags.json },
+        ),
+    );
+    this.output({ json: flags.json }).result(
+      flags.json
+        ? { instance: instance.name, operation: "backup", output }
+        : output,
+    );
+  }
+}

package/src/commands/instance/list.js

@@ -0,0 +1,39 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  writeResult,
+} from "../../instance/command.js";
+import { listInstances } from "../../instance/service.js";
+
+export default class InstanceList extends LocalInstanceCommand {
+  static description = "lista instâncias locais sem revelar credenciais";
+  static flags = {
+    ...contextFlags,
+    json: Flags.boolean({ description: "emite JSON" }),
+  };
+
+  async run() {
+    const { flags } = await this.parse(InstanceList);
+    const context = await this.localContext(contextInput(flags));
+    const instances = (
+      await listInstances(context, this.adapters.filesystem)
+    ).map(({ env, ...item }) => item);
+    writeResult(
+      this,
+      instances,
+      (items) =>
+        items.length
+          ? items
+              .map(
+                (item) =>
+                  `${item.name}\tMongo ${item.mongoPort}\tAPI ${item.apiPort}\tUI ${item.uiPort}\t${item.directory}`,
+              )
+              .join("\n")
+          : `Nenhuma instância encontrada em ${context.instancesDirectory}.`,
+      flags.json,
+    );
+  }
+}

package/src/commands/instance/remove.js

@@ -0,0 +1,72 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+} from "../../instance/command.js";
+import {
+  executeInstanceScript,
+  getInstance,
+  removeArguments,
+} from "../../instance/service.js";
+
+export default class InstanceRemove extends LocalInstanceCommand {
+  static description =
+    "remove uma instância preservando bind mounts externos por padrão";
+  static args = { instance: instanceArgument };
+  static flags = {
+    ...contextFlags,
+    "delete-external-data": Flags.boolean({
+      description: "apaga também bind mounts externos validados",
+    }),
+    yes: Flags.boolean({ char: "y", description: "confirma a remoção" }),
+    json: Flags.boolean({ description: "emite resultado JSON" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceRemove);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    if (!flags.yes) {
+      if (!context.isInteractive)
+        this.error("Remoção exige --yes em modo não interativo.", {
+          code: "CONFIRMATION_REQUIRED",
+          exit: 2,
+        });
+      const confirmation = await this.adapters.prompts.ask({
+        name: "confirmation",
+        type: "input",
+        message: `Digite ${instance.name} para confirmar a remoção`,
+      });
+      if (confirmation !== instance.name)
+        this.error("Remoção cancelada.", {
+          code: "CONFIRMATION_MISMATCH",
+          exit: 2,
+        });
+    }
+    const output = await executeInstanceScript(
+      removeArguments(instance, context, {
+        deleteExternalData: flags["delete-external-data"],
+      }),
+      context,
+      this.adapters.processRunner,
+      { silent: flags.json },
+    );
+    this.output({ json: flags.json }).result(
+      flags.json
+        ? {
+            instance: instance.name,
+            operation: "remove",
+            externalDataDeleted: flags["delete-external-data"],
+            output,
+          }
+        : output,
+    );
+  }
+}

package/src/commands/instance/restore.js

@@ -0,0 +1,96 @@
+import { Flags } from "@oclif/core";
+
+import { LocalInstanceCommand } from "../../baseCommands.js";
+import {
+  contextFlags,
+  contextInput,
+  instanceArgument,
+} from "../../instance/command.js";
+import {
+  executeInstanceScript,
+  getInstance,
+  restoreArguments,
+  withPasswordFile,
+} from "../../instance/service.js";
+
+export default class InstanceRestore extends LocalInstanceCommand {
+  static description =
+    "restaura um backup completo preservando a configuração do host de destino";
+  static args = { instance: instanceArgument };
+  static flags = {
+    ...contextFlags,
+    archive: Flags.string({
+      char: "a",
+      required: true,
+      description: "backup criptografado",
+    }),
+    "password-file": Flags.string({
+      description: "arquivo privado contendo a senha",
+    }),
+    yes: Flags.boolean({
+      char: "y",
+      description: "confirma a substituição dos dados",
+    }),
+    json: Flags.boolean({ description: "emite resultado JSON" }),
+  };
+
+  async run() {
+    const { args, flags } = await this.parse(InstanceRestore);
+    const context = await this.localContext(contextInput(flags, args.instance));
+    const instance = await getInstance(
+      context,
+      this.adapters.filesystem,
+      args.instance,
+    );
+    if (!flags.yes) {
+      if (!context.isInteractive)
+        this.error("Restauração exige --yes em modo não interativo.", {
+          code: "CONFIRMATION_REQUIRED",
+          exit: 2,
+        });
+      const confirmation = await this.adapters.prompts.ask({
+        name: "confirmation",
+        type: "input",
+        message: `Digite ${instance.name} para confirmar a restauração`,
+      });
+      if (confirmation !== instance.name)
+        this.error("Restauração cancelada.", {
+          code: "CONFIRMATION_MISMATCH",
+          exit: 2,
+        });
+    }
+    let password;
+    if (!flags["password-file"]) {
+      if (!context.isInteractive)
+        this.error("Informe --password-file em modo não interativo.", {
+          code: "BACKUP_PASSWORD_REQUIRED",
+          exit: 2,
+        });
+      password = await this.adapters.prompts.ask({
+        name: "password",
+        type: "password",
+        message: "Senha do backup",
+      });
+    }
+    const output = await withPasswordFile(
+      this.adapters.filesystem,
+      password,
+      flags["password-file"],
+      (passwordFile) =>
+        executeInstanceScript(
+          restoreArguments(instance, context, {
+            archive: flags.archive,
+            passwordFile,
+          }),
+          context,
+          this.adapters.processRunner,
+          { secrets: password ? [password] : [], silent: flags.json },
+        ),
+    );
+    this.output({ json: flags.json }).result(
+      flags.json
+        ? { instance: instance.name, operation: "restore", output }
+        : output,
+    );
+  }
+}