@coalescesoftware/coa 1.0.153 → 1.0.157

package/src/Plan.ts

@@ -0,0 +1,29 @@
+import * as Shared from "@coalescesoftware/shared"
+import fs from "fs"
+
+export const CreatePlan = (
+    path: string,
+    environmentID: number,
+    token: string,
+    message: string,
+    runtimeParameters: Shared.Runner.TRunTimeParametersStringType
+) => {
+    const fsSettings: Shared.GitOperations.Filesystem = { 
+        fs: fs,
+        dir: path,
+    }
+    
+    return Shared.DeployOperations.CreatePlanCLI(
+        environmentID,
+        fsSettings,
+        token,
+        Shared.Templates.PlatformType.snowflake,
+        runtimeParameters,
+    )
+        .then(result => {
+            const { plan } = result
+            plan.gitInfo = { commit: { message: message }, oid: "" }
+
+            return result
+        })
+}

package/src/Refresh.ts

@@ -0,0 +1,67 @@
+import * as Shared from "@coalescesoftware/shared"
+import * as CommonCLI from "./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 token 
+ * @param runInfo 
+ * @returns 
+ */
+export const RefreshWithCLI = (
+    token: string,
+    runInfo: Shared.Runner.IRunInfo,
+): Promise<Shared.SchedulerOperations.IRunCounterAndRunCompletion> => {
+    let firebase: any
+    let logContext: Shared.Logging.LogContext
+    let RunSQL: Shared.RunStepHelpers.TRunSQL, teamDetailsStored: Shared.ConnectionOperations.ITeamInfoAndFirebase
+
+    return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(
+        token,
+        undefined,
+    )
+        .then((teamInfoAndFirebase: Shared.ConnectionOperations.ITeamInfoAndFirebase) => {
+            teamDetailsStored = teamInfoAndFirebase
+            const { teamInfo: { fbUserID: userID, fbTeamID: teamID } } = teamInfoAndFirebase
+            firebase = teamInfoAndFirebase.firebase
+            const environmentID: string = runInfo.runDetails.environmentID!
+            logContext = Shared.Logging.CreateLogContext(teamID, environmentID, userID)
+            const connectionCache: Shared.Snowflake.ConnectionStorageClass = 
+                new Shared.Snowflake.ConnectionStorageClass()
+
+            RunSQL = Shared.SQLExecutorCreators.CreateRunSQLWithoutScheduler(
+                teamInfoAndFirebase,
+                connectionCache,
+            )
+
+            LogCLI.infoContext(logContext, "Starting refresh (CLI)")
+
+            return CommonCLI.GetUserConnectionForCLI(
+                userID,
+                runInfo
+            )
+        })
+        .then((connection: Shared.ConnectionOperations.IUserConnection) => {
+            return Shared.SchedulerOperations.BECLI_HandleRefresh(
+                runInfo,
+                teamDetailsStored,
+                RunSQL,
+                connection,
+            ) 
+        })
+        .then(({ runCounter, runCompletion }: Shared.SchedulerOperations.IRunCounterAndRunCompletion) => {
+            const cleanupPromise = CommonCLI.CleanupCLIJob(runCompletion, firebase, logContext, "Refresh")
+            
+            return {
+                runCounter,
+                runCompletion: cleanupPromise,
+                logContext,
+            }
+        })
+}

package/src/RunOutput.ts

@@ -0,0 +1,81 @@
+import * as Shared from '@coalescesoftware/shared'
+import * as RunTypes from 'runtypes'
+
+const CLILogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI)
+
+//convert from firestore shape to run output shape
+const cleanRunResult = (nodeID:string,runResult:Shared.RunnerOperations.RunResultInterface):Shared.RunsTypes.TRunResultOutput=> {
+    return {
+        nodeID,
+        queryResultSequence:runResult.queryResultSequence
+    }
+}
+
+
+const GetRunOutputForRunCounter = (firestore: any, teamID, runID: Shared.Runs.TRunID): Promise<Shared.RunsTypes.TRunOutput> => {
+    let runData: Partial<Shared.RunsTypes.TRunOutput> 
+    return Shared.Runs.getRun(firestore, teamID, runID).get()
+        .then((runDataResult/*query snapshot*/) => {
+            if (!runDataResult.docs.length) {
+                const errorMessage = `wasnt able to get exactly one run for runID ${runID}`
+                CLILogger.emergContext({
+                    orgID: teamID
+                }, errorMessage)
+                throw new Error(errorMessage)
+            }
+            const runInfo = runDataResult.docs[0].data()
+            runData = {
+                runResults: {
+                    runStartTime: runInfo.runStartTime,
+                    runEndTime: runInfo.runEndTime,
+                    runType: runInfo.runType,
+                    runStatus: runInfo.runStatus,
+                    runID: runInfo.id,
+                    runResults: []
+                }
+            }
+            return Shared.Runs.getRunRunResultsCollection(firestore,
+                teamID, runID.toString())
+                .get().then((queryResult/*querySnapshot*/) => {
+                    let runResults= {}
+                    queryResult.docs.forEach((runResultDoc) => {
+
+                        const stepCounter = runResultDoc.id
+                        const runResult = runResultDoc.data()
+                        Shared.RunsTypes.RunResult.check(runResult)
+                        runResults[stepCounter] = cleanRunResult(stepCounter,
+                            runResult as Shared.RunnerOperations.RunResultInterface
+                        )
+                    })
+
+                    const executionSequence  = Shared.Runs.GetExecutionSequenceFromRunResults(runResults)
+                    runData.runResults!.runResults = executionSequence.map((stepCounter) => {
+                        return runResults[stepCounter]
+                    })
+                })
+        }).then(() => {
+            return runData as Shared.RunsTypes.TRunOutput;
+        })
+}
+
+export const SaveRunOutputToFile = (runOutputFileLocation: string,
+    runIDString: string, token: string
+): Promise<void> => {
+    return Shared.SchedulerOperations.AuthenticateFirebaseTokenAndRetrieveTeamInfoForCLI(token,
+        undefined
+    ).then((authInfo: Shared.ConnectionOperations.ITeamInfoAndFirebase) => {
+        const { teamInfo, firebase } = authInfo
+        const teamID = teamInfo.fbTeamID
+        const firestore = firebase.firestore()
+        const runID = parseInt(runIDString)
+        return GetRunOutputForRunCounter(firestore,
+            teamID,
+            runID
+        )
+
+    }).then((runOutput: Shared.RunsTypes.TRunOutput) => {
+        Shared.RunsTypes.RRunOutput.check(runOutput)
+        const runOutputJSON = Shared.Common.StringifyFirestoreObject(runOutput)
+        return Shared.Common.WriteFile(runOutputFileLocation , runOutputJSON + "\n")
+    })
+}