@webiny/pulumi-sdk 0.0.0-mt-1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) Webiny
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,89 @@
+# @webiny/pulumi-sdk
+[![](https://img.shields.io/npm/dw/@webiny/pulumi-sdk.svg)](https://www.npmjs.com/package/@webiny/pulumi-sdk) 
+[![](https://img.shields.io/npm/v/@webiny/pulumi-sdk.svg)](https://www.npmjs.com/package/@webiny/pulumi-sdk)
+[![code style: prettier](https://img.shields.io/badge/code_style-prettier-ff69b4.svg?style=flat-square)](https://github.com/prettier/prettier)
+[![PRs Welcome](https://img.shields.io/badge/PRs-welcome-brightgreen.svg?style=flat-square)](http://makeapullrequest.com)
+
+A simple Pulumi Node.JS SDK - programmatically execute Pulumi CLI commands within your Node.js scripts.
+  
+### Example
+
+```ts
+const { Pulumi } = require("@webiny/pulumi-sdk");
+
+// Create a new instance of Pulumi class.
+// Note that Pulumi will be installed automatically on first use, you don't need to install it
+// manually first. That's why the `beforePulumiInstall` and `afterPulumiInstall` are exposed.
+const pulumi = new Pulumi({
+  execa: {
+    cwd: stacksDir,
+    env: { PULUMI_CONFIG_PASSPHRASE: process.env.PULUMI_CONFIG_PASSPHRASE }
+  },
+  args: {
+    secretsProvider: "passphrase"
+  },
+  beforePulumiInstall: () => {
+    console.log(
+      `💡 It looks like this is your first time using ${green(
+        "@webiny/pulumi-sdk"
+      )}.`
+    );
+    spinner.start(`Downloading Pulumi...`);
+  },
+  afterPulumiInstall: () => {
+    spinner.stopAndPersist({
+      symbol: green("✔"),
+      text: `Pulumi downloaded, continuing...`
+    });
+  }
+});
+
+// Use existing stack if possible, otherwise create a new one.
+let stackExists = true;
+try {
+  const { process } = await pulumi.run({ command: ["stack", "select", env] });
+  await process;
+} catch (e) {
+  stackExists = false;
+}
+
+if (!stackExists) {
+  const { process } = await pulumi.run({ command: ["stack", "init", env] });
+  await process;
+}
+
+// If isPreview was set to true in our script, then run `preview` command, otherwise `up`.
+if (isPreview) {
+  const pulumi = new Pulumi();
+  const { toConsole } = await pulumi.run({
+    command: "preview",
+    execa: {
+      cwd: stacksDir,
+      env: { PULUMI_CONFIG_PASSPHRASE: process.env.PULUMI_CONFIG_PASSPHRASE }
+    }
+  });
+  await toConsole();
+} else {
+  const { toConsole } = await pulumi.run({
+    command: "up",
+    args: {
+      yes: true,
+      skipPreview: true
+    }
+  });
+  await toConsole();
+}
+```
+
+### Development
+
+#### Updating versions
+Currently, versions of the Pulumi code are hard-coded. For example, the version of Pulumi CLI we're currently downloading is set to `2.16.2`, the AWS plugin `3.22.0`. We define these in a couple of places:
+
+1. In `src/index.ts`, check `AWS_PLUGIN_VERSION`.
+2. In `src/downloadBinaries.ts`, check `PULUMI_VERSION`.
+3. Finally, in `package.json`, we have the `@pulumi/aws` and `@pulumi/pulumi` in `dependencies`.
+
+When updating versions, make sure the versions in `package.json` and in files mentioned in `1` and `2`, are synced.
+
+And of course, once you change the version, please test with current dev repo at least. Everything should still be deployable from scratch. 

package/downloadBinaries.d.ts

@@ -0,0 +1,2 @@
+declare const _default: (downloadFolder: any, beforeInstall: any, afterInstall: any) => Promise<boolean>;
+export default _default;

package/downloadBinaries.js

@@ -0,0 +1,105 @@
+"use strict";
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.default = void 0;
+
+const os = require("os");
+
+const tar = require("tar");
+
+const fs = require("fs");
+
+const download = require("download");
+
+const path = require("path");
+
+const decompress = require("decompress");
+
+const semver = require("semver"); // We gotta sanitize the package version, since on a few occasions, we've detected the Pulumi version
+// can look like the following: "2.25.2+dirty". We want to ensure only "2.25.2" is returned.
+// @see https://github.com/pulumi/pulumi/issues/6847
+
+
+const getPulumiVersion = () => {
+  const {
+    version
+  } = require("@pulumi/pulumi/package.json");
+
+  return semver.clean(version);
+};
+
+var _default = async (downloadFolder, beforeInstall, afterInstall) => {
+  if (fs.existsSync(downloadFolder)) {
+    return false;
+  }
+
+  if (typeof beforeInstall === "function") {
+    await beforeInstall();
+  }
+
+  const platform = os.platform();
+
+  switch (platform) {
+    case "darwin":
+      await setupDarwin(downloadFolder);
+      break;
+
+    case "linux":
+      await setupLinux(downloadFolder);
+      break;
+
+    case "win32":
+      await setupWindows(downloadFolder);
+      break;
+
+    default:
+      throw Error(`Cannot download Pulumi binaries - platform "${platform}" not supported. Supported ones are "darwin", "linux", and "win32"`);
+  }
+
+  if (typeof afterInstall === "function") {
+    await afterInstall();
+  }
+
+  return true;
+};
+
+exports.default = _default;
+
+async function setupDarwin(downloadFolder) {
+  const version = getPulumiVersion();
+  const filename = `pulumi-v${version}-darwin-x64.tar.gz`;
+  const downloadUrl = "https://get.pulumi.com/releases/sdk/" + filename;
+  await download(downloadUrl, downloadFolder);
+  await tar.extract({
+    cwd: downloadFolder,
+    file: path.join(downloadFolder, filename)
+  });
+  fs.unlinkSync(path.join(downloadFolder, filename));
+}
+
+async function setupWindows(downloadFolder) {
+  const version = getPulumiVersion();
+  const filename = `pulumi-v${version}-windows-x64.zip`;
+  const downloadUrl = "https://get.pulumi.com/releases/sdk/" + filename;
+  await download(downloadUrl, downloadFolder);
+  const archive = path.join(downloadFolder, filename);
+  const destination = path.join(downloadFolder, "pulumi");
+  await decompress(archive, destination, {
+    strip: 2
+  });
+  fs.unlinkSync(path.join(downloadFolder, filename));
+}
+
+async function setupLinux(downloadFolder) {
+  const version = getPulumiVersion();
+  const filename = `pulumi-v${version}-linux-x64.tar.gz`;
+  const downloadUrl = "https://get.pulumi.com/releases/sdk/" + filename;
+  await download(downloadUrl, downloadFolder);
+  await tar.extract({
+    cwd: downloadFolder,
+    file: path.join(downloadFolder, filename)
+  });
+  fs.unlinkSync(path.join(downloadFolder, filename));
+}

package/index.d.ts

@@ -0,0 +1,37 @@
+import execa from "execa";
+declare type Command = string | string[];
+declare type PulumiArgs = {
+    [key: string]: string | boolean;
+};
+declare type ExecaArgs = {
+    [key: string]: any;
+};
+declare type Options = {
+    args?: PulumiArgs;
+    execa?: ExecaArgs;
+    beforePulumiInstall?: () => any;
+    afterPulumiInstall?: () => any;
+    pulumiFolder?: string;
+};
+declare type RunArgs = {
+    command: Command;
+    args?: PulumiArgs;
+    execa?: ExecaArgs;
+    beforePulumiInstall?: () => any;
+    afterPulumiInstall?: () => any;
+};
+declare type InstallArgs = {
+    beforePulumiInstall?: () => any;
+    afterPulumiInstall?: () => any;
+};
+export declare const FLAG_NON_INTERACTIVE = "--non-interactive";
+export declare class Pulumi {
+    options: Options;
+    pulumiFolder: string;
+    pulumiDownloadFolder: string;
+    pulumiBinaryPath: string;
+    constructor(options?: Options);
+    run(rawArgs: RunArgs): execa.ExecaChildProcess<string>;
+    install(rawArgs?: InstallArgs): Promise<boolean>;
+}
+export {};

package/index.js

@@ -0,0 +1,126 @@
+"use strict";
+
+var _interopRequireDefault = require("@babel/runtime/helpers/interopRequireDefault");
+
+Object.defineProperty(exports, "__esModule", {
+  value: true
+});
+exports.Pulumi = exports.FLAG_NON_INTERACTIVE = void 0;
+
+var _defineProperty2 = _interopRequireDefault(require("@babel/runtime/helpers/defineProperty"));
+
+var _set2 = _interopRequireDefault(require("lodash/set"));
+
+var _kebabCase2 = _interopRequireDefault(require("lodash/kebabCase"));
+
+var _merge2 = _interopRequireDefault(require("lodash/merge"));
+
+var _os = _interopRequireDefault(require("os"));
+
+var _execa = _interopRequireDefault(require("execa"));
+
+var path = _interopRequireWildcard(require("path"));
+
+var _downloadBinaries = _interopRequireDefault(require("./downloadBinaries"));
+
+function _getRequireWildcardCache(nodeInterop) { if (typeof WeakMap !== "function") return null; var cacheBabelInterop = new WeakMap(); var cacheNodeInterop = new WeakMap(); return (_getRequireWildcardCache = function (nodeInterop) { return nodeInterop ? cacheNodeInterop : cacheBabelInterop; })(nodeInterop); }
+
+function _interopRequireWildcard(obj, nodeInterop) { if (!nodeInterop && obj && obj.__esModule) { return obj; } if (obj === null || typeof obj !== "object" && typeof obj !== "function") { return { default: obj }; } var cache = _getRequireWildcardCache(nodeInterop); if (cache && cache.has(obj)) { return cache.get(obj); } var newObj = {}; var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor; for (var key in obj) { if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) { var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null; if (desc && (desc.get || desc.set)) { Object.defineProperty(newObj, key, desc); } else { newObj[key] = obj[key]; } } } newObj.default = obj; if (cache) { cache.set(obj, newObj); } return newObj; }
+
+function ownKeys(object, enumerableOnly) { var keys = Object.keys(object); if (Object.getOwnPropertySymbols) { var symbols = Object.getOwnPropertySymbols(object); if (enumerableOnly) { symbols = symbols.filter(function (sym) { return Object.getOwnPropertyDescriptor(object, sym).enumerable; }); } keys.push.apply(keys, symbols); } return keys; }
+
+function _objectSpread(target) { for (var i = 1; i < arguments.length; i++) { var source = arguments[i] != null ? arguments[i] : {}; if (i % 2) { ownKeys(Object(source), true).forEach(function (key) { (0, _defineProperty2.default)(target, key, source[key]); }); } else if (Object.getOwnPropertyDescriptors) { Object.defineProperties(target, Object.getOwnPropertyDescriptors(source)); } else { ownKeys(Object(source)).forEach(function (key) { Object.defineProperty(target, key, Object.getOwnPropertyDescriptor(source, key)); }); } } return target; }
+
+const FLAG_NON_INTERACTIVE = "--non-interactive";
+exports.FLAG_NON_INTERACTIVE = FLAG_NON_INTERACTIVE;
+
+class Pulumi {
+  constructor(options = {}) {
+    (0, _defineProperty2.default)(this, "options", void 0);
+    (0, _defineProperty2.default)(this, "pulumiFolder", void 0);
+    (0, _defineProperty2.default)(this, "pulumiDownloadFolder", void 0);
+    (0, _defineProperty2.default)(this, "pulumiBinaryPath", void 0);
+    this.options = options;
+    this.pulumiDownloadFolder = path.join(options.pulumiFolder || process.cwd(), "pulumi-cli", _os.default.platform());
+    this.pulumiFolder = path.join(this.pulumiDownloadFolder, "pulumi");
+    this.pulumiBinaryPath = path.join(this.pulumiFolder, "pulumi");
+  }
+
+  run(rawArgs) {
+    const args = (0, _merge2.default)({}, this.options, rawArgs);
+
+    if (!Array.isArray(args.command)) {
+      args.command = [args.command];
+    } // 1. Prepare Pulumi args.
+
+
+    const finalArgs = [];
+
+    for (const key in args.args) {
+      const value = args.args[key];
+
+      if (!value) {
+        continue;
+      }
+
+      if (Array.isArray(value)) {
+        for (let i = 0; i < value.length; i++) {
+          finalArgs.push(`--${(0, _kebabCase2.default)(key)}`, value[i]);
+        }
+
+        continue;
+      }
+
+      if (typeof value === "boolean") {
+        finalArgs.push(`--${(0, _kebabCase2.default)(key)}`);
+        continue;
+      }
+
+      finalArgs.push(`--${(0, _kebabCase2.default)(key)}`, value);
+    } // Prepare execa args.
+
+
+    (0, _set2.default)(args.execa, "env.PULUMI_SKIP_UPDATE_CHECK", "true");
+    (0, _set2.default)(args.execa, "env.PULUMI_HOME", this.pulumiFolder);
+
+    const execaArgs = _objectSpread(_objectSpread({}, args.execa), {}, {
+      env: _objectSpread(_objectSpread({}, args.execa.env || {}), {}, {
+        /**
+         * Due to an issue with Pulumi https://github.com/pulumi/pulumi/issues/8374, and even though this
+         * commit suggests it should already work like that https://github.com/pulumi/pulumi/commit/c878916901a997a9c0ffcbed23560e19e224a6f1,
+         * we need to specify the exact location of our Pulumi binaries, using the PATH environment variable, so it can correctly resolve
+         * plugins necessary for custom resources and dynamic providers to work.
+         */
+        PATH: `${process.env.PATH};${this.pulumiFolder}`
+      })
+    }); // We want to keep the "interactive" output format of the Pulumi command when `--preview` flag is passed in.
+
+
+    const flags = args.command && args.command.includes("preview") ? [] : [FLAG_NON_INTERACTIVE];
+    return (0, _execa.default)(this.pulumiBinaryPath, [...args.command, ...finalArgs, ...flags], execaArgs);
+  }
+
+  async install(rawArgs) {
+    const args = (0, _merge2.default)({}, this.options, rawArgs);
+    const installed = await (0, _downloadBinaries.default)(this.pulumiDownloadFolder, args.beforePulumiInstall, args.afterPulumiInstall);
+
+    if (installed) {
+      const {
+        version
+      } = require("@pulumi/aws/package.json");
+
+      await (0, _execa.default)(this.pulumiBinaryPath, ["plugin", "install", "resource", "aws", version], {
+        stdio: "inherit",
+        env: {
+          PULUMI_HOME: this.pulumiFolder,
+          PULUMI_SKIP_UPDATE_CHECK: "true"
+        }
+      });
+    }
+
+    return installed;
+  }
+
+}
+
+exports.Pulumi = Pulumi;

package/package.json

@@ -0,0 +1,48 @@
+{
+	"name": "@webiny/pulumi-sdk",
+	"version": "0.0.0-mt-1",
+	"main": "index.js",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/webiny/webiny-js.git"
+	},
+	"description": "A simple Node.js Pulumi SDK.",
+	"author": "Webiny Ltd",
+	"license": "MIT",
+	"publishConfig": {
+		"access": "public",
+		"directory": "dist"
+	},
+	"dependencies": {
+		"@pulumi/aws": "^4.10.0",
+		"@pulumi/pulumi": "< 3.18.0",
+		"decompress": "4.2.1",
+		"download": "5.0.3",
+		"execa": "4.1.0",
+		"lodash": "4.17.21",
+		"semver": "7.3.5",
+		"tar": "6.1.11"
+	},
+	"devDependencies": {
+		"@babel/cli": "^7.5.5",
+		"@babel/core": "^7.5.5",
+		"@types/node": "^10.0.0",
+		"@webiny/cli": "^0.0.0-mt-1",
+		"@webiny/project-utils": "^0.0.0-mt-1",
+		"rimraf": "^3.0.2",
+		"typescript": "^4.1.3"
+	},
+	"adio": {
+		"ignore": {
+			"dependencies": [
+				"@pulumi/pulumi",
+				"@pulumi/aws"
+			]
+		}
+	},
+	"scripts": {
+		"build": "yarn webiny run build",
+		"watch": "yarn webiny run watch"
+	},
+	"gitHead": "37736d8456a6ecb342a6c3645060bd9a3f2d4bb0"
+}