@highstate/designer 0.4.4 → 0.4.5

package/.output/server/node_modules/@pulumi/pulumi/automation/minimumVersion.js

@@ -0,0 +1,28 @@
+"use strict";
+// Copyright 2016-2021, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const semver = __importStar(require("semver"));
+/**
+ * @internal
+ */
+exports.minimumVersion = new semver.SemVer("v3.2.0-alpha");
+//# sourceMappingURL=minimumVersion.js.map

package/.output/server/node_modules/@pulumi/pulumi/automation/remoteStack.js

@@ -0,0 +1,130 @@
+"use strict";
+// Copyright 2016-2022, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+Object.defineProperty(exports, "__esModule", { value: true });
+const localWorkspace_1 = require("./localWorkspace");
+/**
+ * {@link RemoteStack} is an isolated, independently configurable instance of a
+ * Pulumi program that is operated on remotely.
+ */
+class RemoteStack {
+    constructor(stack) {
+        this.stack = stack;
+        const ws = stack.workspace;
+        if (!(ws instanceof localWorkspace_1.LocalWorkspace)) {
+            throw new Error("expected workspace to be an instance of LocalWorkspace");
+        }
+    }
+    /**
+     * @internal
+     */
+    static create(stack) {
+        return new RemoteStack(stack);
+    }
+    /**
+     * The name identifying the Stack.
+     */
+    get name() {
+        return this.stack.name;
+    }
+    /**
+     * Creates or updates the resources in a stack by executing the program in
+     * the Workspace. This operation runs remotely.
+     *
+     * @param opts
+     *  Options to customize the behavior of the update.
+     *
+     * @see https://www.pulumi.com/docs/cli/commands/pulumi_up/
+     */
+    up(opts) {
+        return this.stack.up(opts);
+    }
+    /**
+     * Performs a dry-run update to a stack, returning pending changes. This
+     * operation runs remotely.
+     *
+     * @param opts
+     *  Options to customize the behavior of the preview.
+     *
+     * @see https://www.pulumi.com/docs/cli/commands/pulumi_preview/
+     */
+    preview(opts) {
+        return this.stack.preview(opts);
+    }
+    /**
+     * Compares the current stack’s resource state with the state known to exist
+     * in the actual cloud provider. Any such changes are adopted into the
+     * current stack. This operation runs remotely.
+     *
+     * @param opts
+     *  Options to customize the behavior of the refresh.
+     */
+    refresh(opts) {
+        return this.stack.refresh(opts);
+    }
+    /**
+     * Deletes all resources in a stack, leaving all history and configuration
+     * intact. This operation runs remotely.
+     *
+     * @param opts
+     *  Options to customize the behavior of the destroy.
+     */
+    destroy(opts) {
+        return this.stack.destroy(opts);
+    }
+    /**
+     * Gets the current set of stack outputs from the last {@link Stack.up}.
+     */
+    outputs() {
+        return this.stack.outputs();
+    }
+    /**
+     * Returns a list summarizing all previous and current results from Stack
+     * lifecycle operations (up/preview/refresh/destroy).
+     */
+    history(pageSize, page) {
+        // TODO: Find a way to allow showSecrets as an option that doesn't require loading the project.
+        return this.stack.history(pageSize, page, false);
+    }
+    /**
+     * Stops a stack's currently running update. It returns an error if no
+     * update is currently running. Note that this operation is _very
+     * dangerous_, and may leave the stack in an inconsistent state if a
+     * resource operation was pending when the update was canceled.
+     */
+    cancel() {
+        return this.stack.cancel();
+    }
+    /**
+     * Exports the deployment state of the stack. This can be combined with
+     * {@link Stack.importStack} to edit a stack's state (such as recovery from
+     * failed deployments).
+     */
+    exportStack() {
+        return this.stack.exportStack();
+    }
+    /**
+     * Imports the specified deployment state into a pre-existing stack. This
+     * can be combined with {@link Stack.exportStack} to edit a stack's state
+     * (such as recovery from failed deployments).
+     *
+     * @param state
+     *  The stack state to import.
+     */
+    importStack(state) {
+        return this.stack.importStack(state);
+    }
+}
+exports.RemoteStack = RemoteStack;
+//# sourceMappingURL=remoteStack.js.map

package/.output/server/node_modules/@pulumi/pulumi/automation/remoteWorkspace.js

@@ -0,0 +1,131 @@
+"use strict";
+// Copyright 2016-2022, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const localWorkspace_1 = require("./localWorkspace");
+const remoteStack_1 = require("./remoteStack");
+const stack_1 = require("./stack");
+/**
+ * {@link RemoteWorkspace} is the execution context containing a single remote
+ * Pulumi project.
+ */
+class RemoteWorkspace {
+    /**
+     * Creates a stack backed by a {@link RemoteWorkspace} with source code from
+     * the specified Git repository. Pulumi operations on the stack (preview,
+     * update, refresh, and destroy) are performed remotely.
+     *
+     * @param args
+     *  A set of arguments to initialize a {@link RemoteStack} with a remote
+     *  Pulumi program from a Git repository.
+     * @param opts
+     *  Additional customizations to be applied to the Workspace.
+     */
+    static createStack(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ws = yield createLocalWorkspace(args, opts);
+            const stack = yield stack_1.Stack.create(args.stackName, ws);
+            return remoteStack_1.RemoteStack.create(stack);
+        });
+    }
+    /**
+     * Selects an existing stack backed by a {@link RemoteWorkspace} with source
+     * code from the specified Git repository. Pulumi operations on the stack
+     * (preview, update, refresh, and destroy) are performed remotely.
+     *
+     * @param args
+     *  A set of arguments to initialize a {@link RemoteStack} with a remote
+     *  Pulumi program from a Git repository.
+     * @param opts
+     *  Additional customizations to be applied to the Workspace.
+     */
+    static selectStack(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ws = yield createLocalWorkspace(args, opts);
+            const stack = yield stack_1.Stack.select(args.stackName, ws);
+            return remoteStack_1.RemoteStack.create(stack);
+        });
+    }
+    /**
+     * Creates or selects an existing stack backed by a {@link RemoteWorkspace}
+     * with source code from the specified Git repository. Pulumi operations on
+     * the stack (preview, update, refresh, and destroy) are performed remotely.
+     *
+     * @param args
+     *  A set of arguments to initialize a RemoteStack with a remote Pulumi program from a Git repository.
+     * @param opts
+     *  Additional customizations to be applied to the Workspace.
+     */
+    static createOrSelectStack(args, opts) {
+        return __awaiter(this, void 0, void 0, function* () {
+            const ws = yield createLocalWorkspace(args, opts);
+            const stack = yield stack_1.Stack.createOrSelect(args.stackName, ws);
+            return remoteStack_1.RemoteStack.create(stack);
+        });
+    }
+    constructor() { } // eslint-disable-line @typescript-eslint/no-empty-function
+}
+exports.RemoteWorkspace = RemoteWorkspace;
+function createLocalWorkspace(args, opts) {
+    return __awaiter(this, void 0, void 0, function* () {
+        if (!isFullyQualifiedStackName(args.stackName)) {
+            throw new Error(`stack name "${args.stackName}" must be fully qualified.`);
+        }
+        if (!args.url && !(opts === null || opts === void 0 ? void 0 : opts.inheritSettings)) {
+            throw new Error("url is required if inheritSettings is not set.");
+        }
+        if (args.branch && args.commitHash) {
+            throw new Error("branch and commitHash cannot both be specified.");
+        }
+        if (!args.branch && !args.commitHash && !(opts === null || opts === void 0 ? void 0 : opts.inheritSettings)) {
+            throw new Error("either branch or commitHash is required if inheritSettings is not set.");
+        }
+        if (args.auth) {
+            if (args.auth.sshPrivateKey && args.auth.sshPrivateKeyPath) {
+                throw new Error("sshPrivateKey and sshPrivateKeyPath cannot both be specified.");
+            }
+        }
+        const localOpts = {
+            remote: true,
+            remoteGitProgramArgs: args,
+            remoteEnvVars: opts === null || opts === void 0 ? void 0 : opts.envVars,
+            remotePreRunCommands: opts === null || opts === void 0 ? void 0 : opts.preRunCommands,
+            remoteSkipInstallDependencies: opts === null || opts === void 0 ? void 0 : opts.skipInstallDependencies,
+            remoteInheritSettings: opts === null || opts === void 0 ? void 0 : opts.inheritSettings,
+        };
+        return yield localWorkspace_1.LocalWorkspace.create(localOpts);
+    });
+}
+/**
+ * @internal
+ *  Exported only so it can be tested.
+ */
+function isFullyQualifiedStackName(stackName) {
+    if (!stackName) {
+        return false;
+    }
+    const split = stackName.split("/");
+    return split.length === 3 && !!split[0] && !!split[1] && !!split[2];
+}
+exports.isFullyQualifiedStackName = isFullyQualifiedStackName;
+//# sourceMappingURL=remoteWorkspace.js.map

package/.output/server/node_modules/@pulumi/pulumi/automation/server.js

@@ -0,0 +1,170 @@
+"use strict";
+// Copyright 2016-2022, Pulumi Corporation.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result["default"] = mod;
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const errors_1 = require("../errors");
+const log = __importStar(require("../log"));
+const runtimeConfig = __importStar(require("../runtime/config"));
+const debuggable = __importStar(require("../runtime/debuggable"));
+const settings = __importStar(require("../runtime/settings"));
+const stack = __importStar(require("../runtime/stack"));
+const localState = __importStar(require("../runtime/state"));
+const langproto = __importStar(require("../proto/language_pb"));
+const plugproto = __importStar(require("../proto/plugin_pb"));
+/**
+ * Raises the gRPC Max Message size from `4194304` (4mb) to `419430400` (400mb).
+ *
+ * @internal
+ */
+exports.maxRPCMessageSize = 1024 * 1024 * 400;
+/**
+ * @internal
+ */
+class LanguageServer {
+    constructor(program) {
+        this.program = program;
+    }
+    onPulumiExit(hasError) {
+        // Check for leaks once the CLI exits but skip if the program otherwise
+        // errored to keep error output clean
+        if (!hasError) {
+            const [leaks, leakMessage] = debuggable.leakedPromises();
+            if (leaks.size !== 0) {
+                throw new Error(leakMessage);
+            }
+        }
+    }
+    getRequiredPlugins(call, callback) {
+        const resp = new langproto.GetRequiredPluginsResponse();
+        resp.setPluginsList([]);
+        callback(undefined, resp);
+    }
+    run(call, callback) {
+        const req = call.request;
+        const resp = new langproto.RunResponse();
+        // Setup a new async state store for this run
+        const store = new localState.LocalStore();
+        return localState.asyncLocalStorage.run(store, () => __awaiter(this, void 0, void 0, function* () {
+            var _a;
+            const errorSet = new Set();
+            const uncaughtHandler = newUncaughtHandler(errorSet);
+            try {
+                const args = req.getArgsList();
+                const engineAddr = args && args.length > 0 ? args[0] : "";
+                settings.resetOptions(req.getProject(), req.getStack(), req.getParallel(), engineAddr, req.getMonitorAddress(), req.getDryrun(), req.getOrganization());
+                const config = {};
+                for (const [k, v] of ((_a = req.getConfigMap()) === null || _a === void 0 ? void 0 : _a.entries()) || []) {
+                    config[k] = v;
+                }
+                runtimeConfig.setAllConfig(config, req.getConfigsecretkeysList() || []);
+                process.setMaxListeners(settings.getMaximumListeners());
+                process.on("uncaughtException", uncaughtHandler);
+                // @ts-ignore 'unhandledRejection' will almost always invoke uncaughtHandler with an Error. so
+                // just suppress the TS strictness here.
+                process.on("unhandledRejection", uncaughtHandler);
+                try {
+                    yield stack.runInPulumiStack(this.program);
+                    yield settings.disconnect();
+                    process.off("uncaughtException", uncaughtHandler);
+                    process.off("unhandledRejection", uncaughtHandler);
+                }
+                catch (e) {
+                    yield settings.disconnect();
+                    process.off("uncaughtException", uncaughtHandler);
+                    process.off("unhandledRejection", uncaughtHandler);
+                    if (!errors_1.isGrpcError(e)) {
+                        throw e;
+                    }
+                }
+                if (errorSet.size !== 0 || log.hasErrors()) {
+                    let errorMessage = "";
+                    if (errorSet.size !== 0) {
+                        errorMessage = ": ";
+                        errorSet.forEach((error) => {
+                            errorMessage += `${error.message}, `;
+                        });
+                        errorMessage = errorMessage.slice(0, -2);
+                    }
+                    else {
+                        errorMessage = ". Check logs for more details";
+                    }
+                    throw new Error(`One or more errors occurred${errorMessage}`);
+                }
+            }
+            catch (e) {
+                const err = e instanceof Error ? e : new Error(`unknown error ${e}`);
+                resp.setError(err.message);
+                callback(err, undefined);
+            }
+            callback(undefined, resp);
+        }));
+    }
+    getPluginInfo(call, callback) {
+        const resp = new plugproto.PluginInfo();
+        resp.setVersion("1.0.0");
+        callback(undefined, resp);
+    }
+}
+exports.LanguageServer = LanguageServer;
+function newUncaughtHandler(errorSet) {
+    return (err) => {
+        // In node, if you throw an error in a chained promise, but the exception is not finally
+        // handled, then you can end up getting an unhandledRejection for each exception/promise
+        // pair.  Because the exception is the same through all of these, we keep track of it and
+        // only report it once so the user doesn't get N messages for the same thing.
+        if (errorSet.has(err)) {
+            return;
+        }
+        errorSet.add(err);
+        // Default message should be to include the full stack (which includes the message), or
+        // fallback to just the message if we can't get the stack.
+        //
+        // If both the stack and message are empty, then just stringify the err object itself. This
+        // is also necessary as users can throw arbitrary things in JS (including non-Errors).
+        let defaultMessage = "";
+        if (err) {
+            defaultMessage = err.stack || err.message || "" + err;
+        }
+        // First, log the error.
+        if (errors_1.RunError.isInstance(err)) {
+            // Always hide the stack for RunErrors.
+            log.error(err.message);
+        }
+        else if (errors_1.ResourceError.isInstance(err)) {
+            // Hide the stack if requested to by the ResourceError creator.
+            const message = err.hideStack ? err.message : defaultMessage;
+            log.error(message, err.resource);
+        }
+        else if (!errors_1.isGrpcError(err)) {
+            log.error(`Unhandled exception: ${defaultMessage}`);
+        }
+    };
+}
+//# sourceMappingURL=server.js.map