@hiiretail/gcp-infra-generators 1.0.0 → 1.0.1

package/dist/src/BaseGenerator.js

@@ -0,0 +1,84 @@
+const Generator = require('yeoman-generator');
+const path = require('path');
+const fs = require('fs');
+const inquirer = require('inquirer');
+const { chain, required, filename } = require('./validators');
+
+module.exports = class extends Generator {
+  constructor(args, opts) {
+    super(args, opts);
+
+    this.baseDir = path.resolve(path.join(__dirname, '..'));
+    this.destinationRoot(process.cwd());
+
+    const [command, generator] = opts.namespace.split(':').slice(-2);
+    this.generatorId = path.join(command, generator);
+    this.sourceRoot(
+      path.join(this.baseDir, 'generators', this.generatorId, 'templates'),
+    );
+
+    this.copyDir = (
+      templateDir,
+      targetDir,
+      answers = this.answers,
+      skipIfExists = false,
+    ) => {
+      if (skipIfExists && fs.existsSync(targetDir)) {
+        return;
+      }
+      this.fs.copyTpl(
+        this.templatePath(`${templateDir}/**/*`),
+        this.destinationPath(targetDir),
+        answers,
+      );
+    };
+
+    this.listSubDirectories = (parent) =>
+      fs
+        .readdirSync(parent)
+        .filter((f) => !f.startsWith('.'))
+        .filter((f) => fs.lstatSync(path.join(parent, f)).isDirectory())
+        .sort((a, b) => a.localeCompare(b));
+
+    this.kebabCase = (input) => input.replace(/\s|_/g, '-');
+
+    this.chooseOrCreatePrompts = (name, getChoicesDirectory) => [
+      {
+        when: (answers) => fs.existsSync(getChoicesDirectory(answers)),
+        type: 'list',
+        name,
+        message: `Choose ${name}`,
+        store: true,
+        choices: (answers) => [
+          ...this.listSubDirectories(getChoicesDirectory(answers)),
+          new inquirer.Separator(),
+          `Create new ${name}`,
+        ],
+        validate: required,
+        filter: this.kebabCase,
+      },
+      {
+        when: (answers) =>
+          !fs.existsSync(getChoicesDirectory(answers)) ||
+          answers[name] === `Create-new-${name}`,
+        type: 'input',
+        name: `new-${name}`,
+        message: `New ${name} name`,
+        store: false,
+        validate: (input) => chain(input, required, filename),
+        filter: this.kebabCase,
+      },
+      {
+        when: (answers) =>
+          !fs.existsSync(getChoicesDirectory(answers)) ||
+          answers[name] === 'Create-new-tribe',
+        type: 'input',
+        name: 'costCenter',
+        message: 'Please provide the Cost Center of the Tribe',
+        store: false,
+        validate: (input) => chain(input, required, filename),
+        filter: this.kebabCase,
+      },
+    ];
+  }
+};

package/dist/src/SecretsGenerator.js

@@ -0,0 +1,137 @@
+const path = require('path');
+const fs = require('fs');
+const printf = require('sprintf-js').sprintf;
+const chalk = require('chalk');
+const BaseGenerator = require('./BaseGenerator');
+
+function getMaxStrLength(strings) {
+  let maxLength = 0;
+  Object.values(strings).forEach((string) => {
+    if (string.length > maxLength) {
+      maxLength = string.length;
+    }
+  });
+  return maxLength;
+}
+
+module.exports = class extends BaseGenerator {
+  writeSecrets(resource, instanceResource, instanceType, resourceName) {
+    ['prod', 'staging'].forEach((env) => {
+      this.init(env, resource, instanceResource, instanceType, resourceName);
+
+      if (fs.existsSync(path.resolve(this.secretsDir, 'terragrunt.hcl'))) {
+        fs.unlinkSync(path.join(this.secretsDir, 'terragrunt.hcl'));
+      } else {
+        fs.mkdirSync(this.secretsDir, { recursive: true });
+      }
+      this.createTemplate();
+    });
+  }
+
+  init(env, resource, instanceResource, instanceType, resourceName) {
+    this.resourceName = resourceName;
+    this.instanceType = instanceType;
+    this.resource = resource;
+    this.outputs = JSON.parse(
+      fs.readFileSync(
+        path.join(
+          this.baseDir,
+          'generators',
+          this.generatorId,
+          'templates',
+          this.instanceType,
+          'outputs.json',
+        ),
+        'utf8',
+      ),
+    );
+    this.secretsDir = path.join(
+      'infra',
+      env,
+      resource,
+      instanceType,
+      instanceResource,
+      'secrets',
+    );
+    if (fs.existsSync(path.join(this.secretsDir, 'state.json'))) {
+      this.stateNames = JSON.parse(
+        fs.readFileSync(path.join(this.secretsDir, 'state.json'), 'utf8'),
+      );
+      this.checkUniqueState();
+      this.stateNames.secrets.push(this.resourceName);
+    } else {
+      this.stateNames = { secrets: [this.resourceName] };
+    }
+    this.outputLen = getMaxStrLength(this.outputs);
+    this.stateLen = getMaxStrLength(this.stateNames.secrets);
+  }
+
+  checkUniqueState() {
+    this.stateNames.secrets.forEach((state) => {
+      if (state === this.resourceName) {
+        process.stderr.write(
+          `${chalk.red('ERROR!')} resource already exists\n`,
+        );
+        process.exit(1);
+      }
+    });
+  }
+
+  buildDependencies() {
+    const dependencies = [];
+    this.stateNames.secrets.forEach((secret) => {
+      let fp = `dependency "${secret}" {\n  config_path = "../${secret}"\n  mock_outputs = {\n`;
+      Object.values(this.outputs).forEach((value) => {
+        fp += printf(
+          `%-4s%-${this.outputLen}s %s`,
+          '',
+          `${value}`,
+          `= "dummy-${value}"\n`,
+        );
+      });
+      fp += '  }\n}\n';
+      dependencies.push(fp);
+    });
+    return dependencies;
+  }
+
+  buildSecrets() {
+    const secrets = [];
+    const resourceType =
+      this.instanceType === '' ? this.resource : this.instanceType;
+    const padding = resourceType.length + this.outputLen + this.stateLen + 2;
+    this.stateNames.secrets.forEach((secret) => {
+      const secretsSet = [];
+      Object.values(this.outputs).forEach((value) => {
+        secretsSet.push(
+          printf(
+            `\n%-6s%-${padding}s %s`,
+            '',
+            `${resourceType}_${secret}_${value}`,
+            `= dependency.${secret}.outputs.${value}`,
+          ),
+        );
+      });
+      secrets.push(secretsSet.join(''));
+    });
+    return secrets.join('');
+  }
+
+  updateState() {
+    fs.writeFileSync(
+      path.join(this.secretsDir, 'state.json'),
+      JSON.stringify(this.stateNames, null, 2),
+    );
+  }
+
+  createTemplate() {
+    const dependencies = this.buildDependencies().join('');
+    const secrets = this.buildSecrets();
+    this.updateState();
+    this.copyDir(path.join(this.instanceType, 'secrets'), this.secretsDir, {
+      ...this.answers,
+      dependencies,
+      secrets,
+    });
+  }
+};

package/dist/src/cli.js

@@ -1,283 +1,82 @@
-var __defProp = Object.defineProperty;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __name = (target, value) => __defProp(target, "name", { value, configurable: true });
-var __commonJS = (cb, mod) => function __require() {
-  return mod || (0, cb[__getOwnPropNames(cb)[0]])((mod = { exports: {} }).exports, mod), mod.exports;
-};
-
-// package.json
-var require_package = __commonJS({
-  "package.json"(exports2, module2) {
-    module2.exports = {
-      name: "@hiiretail/gcp-infra-generators",
-      version: "1.0.0",
-      description: "Infrastructure as code generator for GCP.",
-      scripts: {
-        build: "node esbuild.js && npm run build:deps",
-        "build:deps": " npm prune --omit=dev --silent && cp -R ../../node_modules dist"
-      },
-      files: [
-        "dist"
-      ],
-      repository: "github:extenda/gcp-infra-cli",
-      readme: "https://github.com/extenda/gcp-infra-cli/tree/master/packages/generators#readme",
-      author: {
-        name: "Extenda Retail",
-        email: "info@extendaretail.com",
-        url: "https://extendaretail.com"
-      },
-      license: "MIT",
-      keywords: [
-        "terraform",
-        "terragrunt",
-        "cli"
-      ],
-      dependencies: {
-        "@google-cloud/storage": "^7.16.0",
-        axios: "^1.11.0",
-        chalk: "^4.1.2",
-        commander: "^14.0.0",
-        ejs: "^3.1.10",
-        "enquirer-separator": "^0.1.0",
-        glob: "^11.0.3",
-        inquirer: "^7.3.3",
-        "js-yaml": "^4.1.0",
-        semver: "^7.3.2",
-        "sprintf-js": "^1.1.3",
-        "yeoman-environment": "^2.10.3",
-        "yeoman-generator": "^4.13.0"
-      },
-      devDependencies: {
-        esbuild: "^0.25.8",
-        "mock-fs": "^5.5.0",
-        "yeoman-assert": "^3.1.1",
-        "yeoman-test": "^2.7.0"
-      }
-    };
-  }
-});
-
-// src/yeoman.js
-var require_yeoman = __commonJS({
-  "src/yeoman.js"(exports2, module2) {
-    var fs2 = require("fs");
-    var path2 = require("path");
-    var inquirer = require("inquirer");
-    var yeoman = require("yeoman-environment");
-    var env;
-    var lookupGenerators = /* @__PURE__ */ __name((dir) => {
-      const opts = {
-        packagePaths: dir,
-        localOnly: true,
-        filePatterns: "*/index.js"
-      };
-      const generators = [];
-      env.lookup(opts, () => {
-        Object.values(env.getGeneratorsMeta()).forEach(
-          ({ resolved, namespace }) => {
-            env.register(resolved, namespace);
-            const generatorJson = path2.join(
-              path2.dirname(resolved),
-              "generator.json"
-            );
-            const name = JSON.parse(fs2.readFileSync(generatorJson, "utf8")).name || namespace;
-            generators.push({
-              name,
-              value: namespace
-            });
-          }
-        );
-      });
-      return generators;
-    }, "lookupGenerators");
-    var runYeoman2 = /* @__PURE__ */ __name(async (dir, name, query) => {
-      if (!env) {
-        env = yeoman.createEnv();
-      }
-      const generators = lookupGenerators(dir);
-      if (generators.length === 1) {
-        return env.run(generators[0].value);
-      }
-      if (name) {
-        const match = generators.find((g) => g.value.endsWith(`:${name}`));
-        if (match) {
-          return env.run(match.value);
-        }
-      }
-      return env.adapter.prompt([
-        {
-          type: "list",
-          name: "generator",
-          message: query,
-          choices: [...generators, new inquirer.Separator(), "Exit"],
-          store: false
-        }
-      ]).then(({ generator }) => {
-        if (generator !== "Exit") {
-          return env.run(generator);
-        }
-        return null;
-      });
-    }, "runYeoman");
-    var setEnvironment = /* @__PURE__ */ __name((yeomanEnv) => {
-      env = yeomanEnv;
-    }, "setEnvironment");
-    module2.exports = {
-      runYeoman: runYeoman2,
-      setEnvironment
-    };
-  }
-});
-
-// src/dependency-check.js
-var require_dependency_check = __commonJS({
-  "src/dependency-check.js"(exports2, module2) {
-    var path2 = require("path");
-    var fs2 = require("fs");
-    var chalk = require("chalk");
-    var printAndExit = /* @__PURE__ */ __name((message) => {
-      process.stderr.write(`${chalk.red("ERROR!")} ${message}
-`);
-      process.exit(1);
-    }, "printAndExit");
-    var checkInit = /* @__PURE__ */ __name(() => {
-      if (!fs2.existsSync(path2.join("infra", "common.hcl"))) {
-        printAndExit("Run init before resources");
-      }
-    }, "checkInit");
-    var checkGitRepo = /* @__PURE__ */ __name(() => {
-      if (!fs2.existsSync(path2.join(".git"))) {
-        printAndExit("Run this command in the root of your Git repository");
-      }
-    }, "checkGitRepo");
-    var checkOrgRepo = /* @__PURE__ */ __name(() => {
-      if (!fs2.existsSync(path2.join("organization"))) {
-        printAndExit("Run this command in your organizations infra repository");
-      }
-    }, "checkOrgRepo");
-    var requireCheck = /* @__PURE__ */ __name((dependencies) => {
-      dependencies.forEach((dependency) => {
-        switch (dependency) {
-          case "init":
-            checkInit();
-            break;
-          case "git-repo":
-            checkGitRepo();
-            break;
-          case "org":
-            checkOrgRepo();
-            break;
-          default:
-            throw new Error(`Unsupported check: ${dependency}`);
-        }
-      });
-    }, "requireCheck");
-    module2.exports = {
-      requireCheck
-    };
-  }
-});
-
-// src/update-check.js
-var require_update_check = __commonJS({
-  "src/update-check.js"(exports2, module2) {
-    var semver = require("semver");
-    var chalk = require("chalk");
-    var axios = require("axios");
-    var { version: packageVersion2 } = require_package();
-    var packageName = "@hiiretail/gcp-infra-cli";
-    var getRegistryVersion = /* @__PURE__ */ __name(async () => {
-      return axios.get(`https://registry.npmjs.org/${packageName}`).then((response) => {
-        const {
-          data: {
-            "dist-tags": { latest }
-          }
-        } = response;
-        return latest;
-      });
-    }, "getRegistryVersion");
-    var isUpdateRequired2 = /* @__PURE__ */ __name(async (version = packageVersion2) => {
-      const registryVersion = await getRegistryVersion();
-      return semver.lt(version, registryVersion) && version !== "0.0.1-local";
-    }, "isUpdateRequired");
-    var printUpdateMessage2 = /* @__PURE__ */ __name(async () => {
-      const newVersion = await getRegistryVersion();
-      process.stdout.write(`${chalk.yellow("SOFTWARE UPDATE!")} Version ${newVersion} has been released.
-Please run the following command to upgrade to the latest version:
-
-  ${chalk.green(`npm install --global ${packageName}@latest`)}
-`);
-    }, "printUpdateMessage");
-    module2.exports = {
-      isUpdateRequired: isUpdateRequired2,
-      printUpdateMessage: printUpdateMessage2
-    };
-  }
-});
-
-// src/cli.js
-var path = require("path");
-var fs = require("fs");
-var glob = require("glob");
-var { Command } = require("commander");
-var {
+const path = require('path');
+const fs = require('fs');
+const glob = require('glob');
+const { Command } = require('commander');
+const {
   version: packageVersion,
-  description: packageDescription
-} = require_package();
-var { runYeoman } = require_yeoman();
-var dependencyCheck = require_dependency_check();
-var { isUpdateRequired, printUpdateMessage } = require_update_check();
-var addGenerators = /* @__PURE__ */ __name((commandDir, command, require2) => {
+  description: packageDescription,
+} = require('../package.json');
+const { runYeoman } = require('./yeoman');
+const dependencyCheck = require('./dependency-check');
+const { isUpdateRequired, printUpdateMessage } = require('./update-check');
+
+const addGenerators = (commandDir, command, require) => {
   glob.sync(`${commandDir}/*/generator.json`).forEach((file) => {
     const dir = path.dirname(file);
-    const info = JSON.parse(fs.readFileSync(file, "utf8"));
+    const info = JSON.parse(fs.readFileSync(file, 'utf8'));
     const name = path.basename(dir);
-    command.command(name).description(info.description).action(() => {
-      dependencyCheck.requireCheck(require2);
-      return runYeoman(commandDir, name);
-    });
+    command
+      .command(name)
+      .description(info.description)
+      .action(() => {
+        dependencyCheck.requireCheck(require);
+        return runYeoman(commandDir, name);
+      });
   });
-}, "addGenerators");
-var createCommands = /* @__PURE__ */ __name((program) => {
+};
+
+const createCommands = (program) => {
   const opts = {
-    cwd: path.resolve(__dirname, ".."),
-    absolute: true
+    cwd: path.resolve(__dirname, '..'),
+    absolute: true,
   };
-  glob.sync("generators/*/command.json", opts).forEach((file) => {
+  glob.sync('generators/*/command.json', opts).forEach((file) => {
     const dir = path.dirname(file);
     const name = path.basename(dir);
     const {
-      query = "Choose a generator",
-      description = "",
-      require: require2 = []
-    } = JSON.parse(fs.readFileSync(path.join(file), "utf8"));
-    const command = program.command(name).description(description).action(() => {
-      dependencyCheck.requireCheck(require2);
-      return runYeoman(dir, "", query);
-    });
-    addGenerators(dir, command, require2);
+      query = 'Choose a generator',
+      description = '',
+      require = [],
+    } = JSON.parse(fs.readFileSync(path.join(file), 'utf8'));
+    const command = program
+      .command(name)
+      .description(description)
+      .action(() => {
+        dependencyCheck.requireCheck(require);
+        return runYeoman(dir, '', query);
+      });
+    addGenerators(dir, command, require);
   });
   return program;
-}, "createCommands");
-var cli = /* @__PURE__ */ __name(async (argv, exitOverride, cliVersion = "0.0.1-local") => {
+};
+
+const cli = async (argv, exitOverride, cliVersion = '0.0.1-local') => {
   const needsUpdate = await isUpdateRequired(cliVersion);
   if (needsUpdate) {
     await printUpdateMessage();
     process.exit(1);
   }
+
   const command = new Command();
   if (exitOverride) {
     command.exitOverride(exitOverride);
   }
-  return createCommands(command).version(
-    `gcp-infra              ${cliVersion}
+
+  return createCommands(command)
+    .version(
+      `gcp-infra              ${cliVersion}
 gcp-infra-generators   ${packageVersion}
-`
-  ).description(packageDescription).addHelpCommand(false).parseAsync(argv);
-}, "cli");
+`,
+    )
+    .description(packageDescription)
+    .addHelpCommand(false)
+    .parseAsync(argv);
+};
+
 if (require.main === module) {
   cli().then(() => {
     process.exit(0);
   });
 }
+
 module.exports = cli;

package/dist/src/dependency-check.js

@@ -0,0 +1,48 @@
+const path = require('path');
+const fs = require('fs');
+const chalk = require('chalk');
+
+const printAndExit = (message) => {
+  process.stderr.write(`${chalk.red('ERROR!')} ${message}\n`);
+  process.exit(1);
+};
+
+const checkInit = () => {
+  if (!fs.existsSync(path.join('infra', 'common.hcl'))) {
+    printAndExit('Run init before resources');
+  }
+};
+
+const checkGitRepo = () => {
+  if (!fs.existsSync(path.join('.git'))) {
+    printAndExit('Run this command in the root of your Git repository');
+  }
+};
+
+const checkOrgRepo = () => {
+  if (!fs.existsSync(path.join('organization'))) {
+    printAndExit('Run this command in your organizations infra repository');
+  }
+};
+
+const requireCheck = (dependencies) => {
+  dependencies.forEach((dependency) => {
+    switch (dependency) {
+      case 'init':
+        checkInit();
+        break;
+      case 'git-repo':
+        checkGitRepo();
+        break;
+      case 'org':
+        checkOrgRepo();
+        break;
+      default:
+        throw new Error(`Unsupported check: ${dependency}`);
+    }
+  });
+};
+
+module.exports = {
+  requireCheck,
+};

package/dist/src/update-check.js

@@ -0,0 +1,38 @@
+const semver = require('semver');
+const chalk = require('chalk');
+const axios = require('axios');
+const { version: packageVersion } = require('../package.json');
+const packageName = '@hiiretail/gcp-infra-cli';
+
+const getRegistryVersion = async () => {
+  return axios
+    .get(`https://registry.npmjs.org/${packageName}`)
+    .then((response) => {
+      const {
+        data: {
+          'dist-tags': { latest },
+        },
+      } = response;
+      return latest;
+    });
+};
+
+const isUpdateRequired = async (version = packageVersion) => {
+  const registryVersion = await getRegistryVersion();
+  return semver.lt(version, registryVersion) && version !== '0.0.1-local';
+};
+
+const printUpdateMessage = async () => {
+  const newVersion = await getRegistryVersion();
+  process.stdout
+    .write(`${chalk.yellow('SOFTWARE UPDATE!')} Version ${newVersion} has been released.
+Please run the following command to upgrade to the latest version:
+
+  ${chalk.green(`npm install --global ${packageName}@latest`)}
+`);
+};
+
+module.exports = {
+  isUpdateRequired,
+  printUpdateMessage,
+};

package/dist/src/validators.js

@@ -0,0 +1,33 @@
+const path = require('path');
+
+module.exports = {
+  chain: (input, ...validators) => {
+    let msg = '';
+    validators.every((validator) => {
+      msg = validator(input);
+      return msg === true;
+    });
+    return msg === true ? true : msg;
+  },
+  filename: (input) => {
+    if (!input) {
+      // Optional input OK
+      return true;
+    }
+    return path.basename(input) === input ? true : 'Invalid filename';
+  },
+  maxLength: (input, maxLength) =>
+    !input || input.length <= maxLength
+      ? true
+      : `Exceeds max length: ${maxLength}`,
+  required: (input) => {
+    const msg = 'Required';
+    if (Array.isArray(input)) {
+      return input.length > 0 ? true : msg;
+    }
+    if (input) {
+      return input.trim().length > 0 ? true : msg;
+    }
+    return msg;
+  },
+};