@coalescesoftware/coa 1.0.156 → 1.0.159

package/bin/CLIProfile.js

@@ -0,0 +1,161 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.GetCLIConfig = exports.ICLIProfileExample = exports.GetDefaultLocationForCoaConfigFile = void 0;
+/* eslint-disable multiline-comment-style */
+const Shared = __importStar(require("@coalescesoftware/shared"));
+const immer = __importStar(require("immer"));
+const os = require('os');
+const path = require('path');
+const ini = require('ini');
+const fs = require('fs');
+const RemoveCredentialsFromCLIProfile = (cliProfile) => {
+    return immer.produce(cliProfile, (draft) => {
+        if (draft.snowflakePassword)
+            draft.snowflakePassword = '<REDACTED>';
+        if (draft.snowflakeAccount)
+            draft.snowflakeAccount = '<REDACTED>';
+    });
+};
+const RemoveCredentialsFromCLIProfiles = (cliProfiles) => {
+    return immer.produce(cliProfiles, (draftState) => {
+        Object.keys(draftState).forEach((cliProfileName) => {
+            draftState[cliProfileName] = RemoveCredentialsFromCLIProfile(cliProfiles[cliProfileName]);
+        });
+    });
+};
+const CLILogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI_INTERNAL);
+const GetDefaultLocationForCoaConfigFile = () => {
+    const homedir = os.homedir();
+    const coaConfigLocation = path.join(homedir, ".coa/config");
+    CLILogger.info("using default location", coaConfigLocation);
+    return coaConfigLocation;
+};
+exports.GetDefaultLocationForCoaConfigFile = GetDefaultLocationForCoaConfigFile;
+//voodoo typescript magic in order to get runtime and compiletime ICLIProfile code
+//https://stackoverflow.com/questions/45670705/iterate-over-interface-properties-in-typescript
+exports.ICLIProfileExample = {
+    profile: "Profile To Use",
+    environmentID: "Environment ID",
+    parameters: "Parameters",
+    snowflakeAccount: "Snowflake Account To Use",
+    snowflakeAuthType: "Snowflake Auth Type (Basic, KeyPair)",
+    snowflakeKeyPairPath: "Snowflake Key Pair Path",
+    snowflakeKeyPairPass: "Snowflake Key Pair Pass",
+    snowflakePassword: "Snowflake Password",
+    snowflakeRole: "Snowflake Role",
+    snowflakeUsername: "Snowflake Username",
+    snowflakeWarehouse: "Snowflake Warehouse",
+    token: "Coalesce Token",
+    jobID: "Coalesce JobID",
+    include: "Coalesce Node Selector",
+    exclude: "Coalesce Node Selector"
+};
+const ReadCLIProfiles = (filePath) => {
+    let filePathToUse;
+    if (!filePath) {
+        filePathToUse = (0, exports.GetDefaultLocationForCoaConfigFile)();
+    }
+    else {
+        filePathToUse = filePath;
+    }
+    return fs.promises.readFile(filePathToUse, 'utf-8')
+        .then((file) => {
+        return ini.parse(file);
+    })
+        .catch((err) => {
+        CLILogger.error("unable to read cli profile file filePath:", filePath, err);
+        if (!filePath) //if no filepath was specified, silently proceed
+            return {};
+        else //unable to proceed couldnt read file
+            throw new Error(`unable to read cli profile:${filePathToUse}`);
+    });
+};
+const GetFinalCLIProfile = (commandLineOverrides, configFileLocation) => {
+    let profileToUseOverride = commandLineOverrides.profile ? commandLineOverrides.profile : null;
+    return ReadCLIProfiles(configFileLocation)
+        .then((cliProfiles) => {
+        const defaultCLIProfile = cliProfiles.default;
+        let finalCLIProfile = {};
+        //if theres a default cli profile, start with that
+        if (defaultCLIProfile) {
+            finalCLIProfile = defaultCLIProfile;
+        }
+        //if a profile has been specified, use that
+        const profileToUse = profileToUseOverride || //cli override
+            (!!defaultCLIProfile && defaultCLIProfile.profile) //default profile exists
+            || "";
+        CLILogger.info("using profile", profileToUse, "cliProfiles", JSON.stringify(RemoveCredentialsFromCLIProfiles(cliProfiles)));
+        if (profileToUse) {
+            if (!(profileToUse in cliProfiles)) {
+                throw new Error(`unable to find profile ${profileToUse}`);
+            }
+            const coaConfigProfile = cliProfiles[profileToUse];
+            finalCLIProfile = Object.assign(Object.assign({}, finalCLIProfile), coaConfigProfile);
+        }
+        finalCLIProfile = Object.assign(Object.assign({}, finalCLIProfile), commandLineOverrides);
+        return finalCLIProfile;
+    });
+};
+//Get CLI Config given command line overrides and a config file
+//config file location can be null - which means to use default location
+const GetCLIConfig = (commandLineOverrides, configFileLocation) => {
+    return GetFinalCLIProfile(commandLineOverrides, configFileLocation).then((cliProfile) => {
+        CLILogger.info("got final cli profile configFileLocation:", configFileLocation, JSON.stringify(RemoveCredentialsFromCLIProfile(cliProfile)));
+        const cliConfig = {
+            token: cliProfile.token,
+            runDetails: {
+                environmentID: cliProfile.environmentID,
+                jobID: cliProfile.jobID,
+                includeNodesSelector: cliProfile.include,
+                excludeNodesSelector: cliProfile.exclude
+            },
+            userCredentials: {
+                snowflakeAccount: cliProfile.snowflakeAccount,
+                snowflakeAuthType: cliProfile.snowflakeAuthType,
+                snowflakePassword: cliProfile.snowflakePassword,
+                snowflakeKeyPairPath: cliProfile.snowflakeKeyPairPath,
+                snowflakeKeyPairPass: cliProfile.snowflakeKeyPairPass,
+                snowflakeRole: cliProfile.snowflakeRole,
+                snowflakeUsername: cliProfile.snowflakeUsername,
+                snowflakeWarehouse: cliProfile.snowflakeWarehouse
+            },
+            runtimeParameters: cliProfile.parameters
+        };
+        Shared.Common.CleanupUndefinedValuesFromObject(cliConfig);
+        return cliConfig;
+    });
+};
+exports.GetCLIConfig = GetCLIConfig;
+// TODO: create a profile class that takes the cmd object in the constructor
+// store contents of configuration file
+// if no config file path option
+// check if there's a valid configuration file in the current working directory or home directory
+// if none exists
+// create a configuration file with empty default profile
+// prompt user to either rerun the command with valid config file, per-command flags for all profile values, or run `coa init` to go through prompts for creating a profile
+// if a configuration file exists, but any required property holds a falsy value
+// inform user which fields are missing and prompt to run `coa init` to fill out invalid fields
+// method: validate configuration file
+// method: get final profile for current command
+// create a function getCLIProfile that returns a CLI profile, this should return a promise that resolve in CLI profile
+// hardcode a profile
+//# sourceMappingURL=CLIProfile.js.map

package/bin/CommonCLI.js

@@ -0,0 +1,139 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FinishWithOutputFile = exports.ValidateRuntimeParameters = exports.GetRuntimeParametersFromFirestore = exports.GetUserConnectionForCLI = exports.CleanupCLIJob = void 0;
+const Shared = __importStar(require("@coalescesoftware/shared"));
+const fs = __importStar(require("fs"));
+const crypto = __importStar(require("crypto"));
+const RunOutput = __importStar(require("./RunOutput"));
+const RunnerBackendLogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.RunnerBackend);
+const LogCLIInternal = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI_INTERNAL);
+const CleanupCLIJob = (runCompletion, firebase, logContext, action) => {
+    const cleanupPromise = new Promise((resolve, reject) => {
+        let promiseError = null;
+        runCompletion
+            .catch((error) => {
+            promiseError = error;
+        })
+            .finally(() => {
+            try {
+                if (firebase) {
+                    Shared.Common.DeleteFirebaseInstance(firebase);
+                }
+            }
+            catch (error) {
+                RunnerBackendLogger.errorContext(logContext, `Error during ${action}WithCLI Finally cleanup: `, error);
+            }
+            if (promiseError) {
+                reject(promiseError);
+            }
+            else {
+                resolve();
+            }
+        });
+    });
+    return cleanupPromise;
+};
+exports.CleanupCLIJob = CleanupCLIJob;
+const GetKeyPairKey = (keyPairPath, keyPairPass) => {
+    return new Promise((resolve, reject) => {
+        Shared.Common.assert(Shared.Logging.LoggingArea.RunnerBackend, !!keyPairPath, "ERROR (GetKeyPairPath): invalid or missing keyPairPath");
+        const privateKeyFile = fs.readFileSync(keyPairPath);
+        const privateKeyObject = crypto.createPrivateKey({
+            key: privateKeyFile,
+            format: "pem",
+            passphrase: keyPairPass
+        });
+        const privateKey = privateKeyObject.export({
+            format: "pem",
+            type: "pkcs8"
+        });
+        if (!privateKey) {
+            reject(new Error("ERROR (GetKeyPairPath): invalid or missing privateKey"));
+        }
+        else {
+            resolve(privateKey);
+        }
+    });
+};
+const GetUserConnectionForCLI = (userID, runInfo) => {
+    return new Promise((resolve, reject) => {
+        var _a, _b, _c, _d, _e, _f;
+        const output = {
+            connectionDetails: {
+                userID,
+                user: (_a = runInfo.userCredentials) === null || _a === void 0 ? void 0 : _a.snowflakeUsername,
+                role: (_b = runInfo.userCredentials) === null || _b === void 0 ? void 0 : _b.snowflakeRole,
+                warehouse: (_c = runInfo.userCredentials) === null || _c === void 0 ? void 0 : _c.snowflakeWarehouse,
+            },
+            connectionType: (_d = runInfo.userCredentials) === null || _d === void 0 ? void 0 : _d.snowflakeAuthType
+        };
+        if (!((_e = runInfo.userCredentials) === null || _e === void 0 ? void 0 : _e.snowflakeAuthType)) {
+            reject(new Error("ERROR (GetUserConnectionForCLI): no auth type provided"));
+        }
+        else if (((_f = runInfo.userCredentials) === null || _f === void 0 ? void 0 : _f.snowflakeAuthType) === Shared.ConnectionOperations.EUserConnectionTypes.keyPair) {
+            GetKeyPairKey(Shared.Common.getValueSafe(runInfo, ["userCredentials", "snowflakeKeyPairPath"], ""), Shared.Common.getValueSafe(runInfo, ["userCredentials", "snowflakeKeyPairPass"], ""))
+                .then((keyPair) => {
+                output.connectionDetails.keyPair = keyPair;
+                resolve(output);
+            })
+                .catch((err) => {
+                reject(err);
+            });
+        }
+        else {
+            resolve(output);
+        }
+    });
+};
+exports.GetUserConnectionForCLI = GetUserConnectionForCLI;
+////////
+// Runtime Parameters
+///////
+const GetRuntimeParametersFromFirestore = (firestore, teamID, environmentID) => {
+    return Shared.CommonOperations.getWorkspaceDocumentRefAdmin(firestore, teamID, environmentID).get().then((workspace) => {
+        return workspace.get("runTimeParameters");
+    });
+};
+exports.GetRuntimeParametersFromFirestore = GetRuntimeParametersFromFirestore;
+const ValidateRuntimeParameters = (runtimeParameters) => {
+    try {
+        JSON.parse(runtimeParameters);
+    }
+    catch (error) {
+        throw new Error(`Failed to parse runtime parameters: ${error.message}`);
+    }
+};
+exports.ValidateRuntimeParameters = ValidateRuntimeParameters;
+////////
+// Output File 
+///////
+const FinishWithOutputFile = (logContextToUse, outputFilePath, runCounter, token) => {
+    if (!outputFilePath) {
+        return Promise.resolve();
+    }
+    else {
+        LogCLIInternal.infoContext(logContextToUse, "saving run results to file", outputFilePath);
+        return RunOutput.SaveRunOutputToFile(outputFilePath, runCounter.toString(), token);
+    }
+};
+exports.FinishWithOutputFile = FinishWithOutputFile;
+//# sourceMappingURL=CommonCLI.js.map

package/bin/Deploy.js

@@ -0,0 +1,71 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    Object.defineProperty(o, k2, { enumerable: true, get: function() { return m[k]; } });
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DeployWithCLI = void 0;
+const Shared = __importStar(require("@coalescesoftware/shared"));
+const CommonCLI = __importStar(require("./CommonCLI"));
+const CryptoJS = require("crypto-js");
+const v8 = require("v8");
+Shared.Snowflake.CryptoJS = CryptoJS;
+Shared.Snowflake.salt = CryptoJS.lib.WordArray.random(128 / 8);
+Shared.Snowflake.v8 = v8;
+const LogCLI = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI);
+/**
+ *
+ * @param plan
+ * @param config
+ * @param token
+ * @returns
+ */
+const DeployWithCLI = (plan, config, token) => {
+    let firebase;
+    let logContext;
+    let teamDetailsStored;
+    let RunSQL;
+    let runInfo;
+    return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(token, undefined).then((teamDetails) => {
+        var _a;
+        teamDetailsStored = teamDetails;
+        const { teamInfo, teamInfo: { fbUserID: userID, fbTeamID: teamID } } = teamDetails;
+        firebase = teamDetails.firebase;
+        const environmentID = +((_a = config.runDetails) === null || _a === void 0 ? void 0 : _a.environmentID);
+        logContext = Shared.Logging.CreateLogContext(teamID, environmentID, userID);
+        const connectionCache = new Shared.Snowflake.ConnectionStorageClass();
+        RunSQL = Shared.SQLExecutorCreators.CreateRunSQLWithoutScheduler(teamDetails, connectionCache);
+        runInfo = Shared.DeployOperations.CreateDeployRequestObject(plan.plan, plan.environmentState, teamInfo, plan.gitInfo, plan.targetEnvironment, plan.runtimeParameters);
+        runInfo.userCredentials = config.userCredentials;
+        return CommonCLI.GetUserConnectionForCLI(userID, runInfo);
+    })
+        .then((connection) => {
+        LogCLI.infoContext(logContext, "Deploy starting (CLI)");
+        return Shared.SchedulerOperations.BECLI_HandleDeploy(runInfo, teamDetailsStored, RunSQL, connection);
+    })
+        .then(({ runCounter, runCompletion }) => {
+        const cleanupPromise = CommonCLI.CleanupCLIJob(runCompletion, firebase, logContext, "Deploy");
+        return {
+            runCounter,
+            runCompletion: cleanupPromise,
+            logContext,
+        };
+    });
+};
+exports.DeployWithCLI = DeployWithCLI;
+//# sourceMappingURL=Deploy.js.map