@iacmp/cli 1.1.0

package/dist/commands/destroy.js

@@ -0,0 +1,194 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+
+// src/commands/destroy.ts
+var destroy_exports = {};
+__export(destroy_exports, {
+  default: () => Destroy
+});
+module.exports = __toCommonJS(destroy_exports);
+var import_core = require("@oclif/core");
+var fs3 = __toESM(require("fs"));
+var path2 = __toESM(require("path"));
+var readline = __toESM(require("readline"));
+var import_chalk = __toESM(require("chalk"));
+
+// src/synth-out.ts
+var fs = __toESM(require("fs"));
+var path = __toESM(require("path"));
+function templateExt(provider) {
+  return provider === "terraform" ? ".tf" : ".json";
+}
+function synthRoot(cwd) {
+  return path.join(cwd, "synth-out");
+}
+function providerOutDir(cwd, provider) {
+  return path.join(synthRoot(cwd), provider);
+}
+function hasTemplates(dir, provider) {
+  const ext = templateExt(provider);
+  try {
+    return fs.readdirSync(dir).some((f) => f.endsWith(ext) && fs.statSync(path.join(dir, f)).isFile());
+  } catch {
+    return false;
+  }
+}
+function resolveTemplateDir(cwd, provider) {
+  const dir = providerOutDir(cwd, provider);
+  if (fs.existsSync(dir)) return dir;
+  const root = synthRoot(cwd);
+  if (fs.existsSync(root) && hasTemplates(root, provider)) return root;
+  return null;
+}
+function listTemplates(cwd, provider, stack) {
+  const dir = resolveTemplateDir(cwd, provider);
+  if (!dir) return [];
+  const ext = templateExt(provider);
+  return fs.readdirSync(dir).filter((f) => f.endsWith(ext) && fs.statSync(path.join(dir, f)).isFile()).map((f) => ({
+    stackName: f.slice(0, -ext.length),
+    filePath: path.join(dir, f),
+    fileName: f
+  })).filter((t) => !stack || t.stackName === stack);
+}
+function countResources(filePath, provider) {
+  let content;
+  try {
+    content = fs.readFileSync(filePath, "utf-8");
+  } catch {
+    return 0;
+  }
+  if (provider === "terraform") {
+    const matches = content.match(/^resource\s+"/gm);
+    return matches ? matches.length : 0;
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(content);
+  } catch {
+    return 0;
+  }
+  if (parsed && typeof parsed === "object") {
+    const obj = parsed;
+    if (Array.isArray(obj.resources)) return obj.resources.length;
+    if (obj.Resources && typeof obj.Resources === "object") {
+      return Object.keys(obj.Resources).length;
+    }
+  }
+  return 0;
+}
+
+// src/utils.ts
+var fs2 = __toESM(require("fs"));
+function readJsonFile(filePath) {
+  let content;
+  try {
+    content = fs2.readFileSync(filePath, "utf-8");
+  } catch (e) {
+    throw new Error(`Falha ao ler '${filePath}': ${errMessage(e)}`);
+  }
+  try {
+    return JSON.parse(content);
+  } catch (e) {
+    throw new Error(`JSON inv\xE1lido em '${filePath}': ${errMessage(e)}`);
+  }
+}
+function errMessage(e) {
+  if (e instanceof Error) return e.message;
+  if (typeof e === "string") return e;
+  try {
+    return JSON.stringify(e);
+  } catch {
+    return String(e);
+  }
+}
+
+// src/commands/destroy.ts
+var MVP_BANNER = "MVP: deploy/destroy real ainda n\xE3o implementado nesta fase. Os arquivos foram impressos como dry-run.";
+var Destroy = class _Destroy extends import_core.Command {
+  static description = "Destroi a infraestrutura do provider configurado";
+  static flags = {
+    provider: import_core.Flags.string({ char: "p", description: "Provider alvo", default: "aws" }),
+    stack: import_core.Flags.string({ char: "s", description: "Nome da stack espec\xEDfica" }),
+    force: import_core.Flags.boolean({ char: "f", description: "Pula confirma\xE7\xE3o" })
+  };
+  static examples = [
+    "$ iacmp destroy",
+    "$ iacmp destroy --stack minha-stack",
+    "$ iacmp destroy --force"
+  ];
+  async confirm(message) {
+    const rl = readline.createInterface({ input: process.stdin, output: process.stdout });
+    return new Promise((resolve) => {
+      rl.question(`${message} (y/N): `, (answer) => {
+        rl.close();
+        resolve(answer.toLowerCase() === "y" || answer.toLowerCase() === "yes");
+      });
+    });
+  }
+  async run() {
+    const { flags } = await this.parse(_Destroy);
+    const cwd = process.cwd();
+    const configPath = path2.join(cwd, "iacmp.json");
+    if (!fs3.existsSync(configPath)) {
+      this.error("Projeto n\xE3o inicializado. Rode: iacmp init");
+    }
+    let config;
+    try {
+      config = readJsonFile(configPath);
+    } catch (err) {
+      this.error(errMessage(err));
+    }
+    const provider = flags.provider ?? config.provider ?? "aws";
+    this.log(import_chalk.default.yellow.bold(MVP_BANNER));
+    this.log("");
+    const templates = listTemplates(cwd, provider, flags.stack);
+    if (templates.length === 0) {
+      this.error(`Nenhuma stack encontrada para destruir. Rode: iacmp synth --provider ${provider}`);
+    }
+    let totalResources = 0;
+    const stackNames = [];
+    for (const t of templates) {
+      totalResources += countResources(t.filePath, provider);
+      stackNames.push(t.stackName);
+    }
+    this.log(`Stacks a destruir: ${stackNames.join(", ")}`);
+    this.log(`Total de recursos: ${totalResources} em ${provider.toUpperCase()}`);
+    this.log("");
+    if (!flags.force) {
+      const confirmed = await this.confirm("Tem certeza que deseja destruir esses recursos?");
+      if (!confirmed) {
+        this.log("Opera\xE7\xE3o cancelada.");
+        return;
+      }
+    }
+    this.log(`Would destroy ${totalResources} resource(s) from ${provider.toUpperCase()}`);
+    this.log("");
+    this.log("(MVP: destroy real n\xE3o implementado nesta fase)");
+  }
+};