@coalescesoftware/coa 1.0.120 → 1.0.123

package/src/Plan.ts

@@ -1,29 +0,0 @@
-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

@@ -1,67 +0,0 @@
-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

@@ -1,90 +0,0 @@
-import * as Shared from '@coalescesoftware/shared'
-import { Firestore } from '@google-cloud/firestore'
-import * as fs from 'fs'
-
-const CLILogger = Shared.Logging.GetLogger(Shared.Logging.LoggingArea.CLI)
-
-interface RunResultOutput {
-    nodeID:string,
-    queryResultSequence:Shared.RunnerOperations.QueryResultSequence
-}
-
-interface RunOutput {
-    runResults: {
-        runStartTime: Date,
-        runEndTime: Date,
-        runType: Shared.Runner.ERunStatus,
-        runStatus: Shared.Runner.ERunStatus,
-        runResults: RunResultOutput[],
-        runID: Shared.Runs.TRunID
-    }
-}
-
-const cleanRunResult = (nodeID:string,runResult:Shared.RunnerOperations.RunResultInterface):RunResultOutput=> {
-    return {
-        nodeID,
-        queryResultSequence:runResult.queryResultSequence
-    }
-}
-const GetRunOutputForRunCounter = (firestore: any, teamID, runID: Shared.Runs.TRunID): Promise<RunOutput> => {
-    let runData: Partial<RunOutput> 
-    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()
-                        runResults[stepCounter] = cleanRunResult(stepCounter,
-                            runResult.history[0] as Shared.RunnerOperations.RunResultInterface
-                        )
-                    })
-                    runData.runResults!.runResults = runInfo.runHistory.map((stepCounter) => {
-                        return runResults[stepCounter]
-                    })
-                })
-        }).then(() => {
-            return runData as RunOutput;
-        })
-}
-
-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: RunOutput) => {
-        const runOutputJSON = Shared.Common.StringifyFirestoreObject(runOutput)
-        return Shared.Common.WriteFile(runOutputFileLocation , runOutputJSON + "\n")
-    })
-}