Deploy preview with details which data is going to be updated for each file changed (similar to terraform plan command)

.gitignore

@@ -16,4 +16,6 @@ local
 .tsbuildinfo
 **/checkly-github-report.md
 **/checkly-summary.md
-**/e2e/__tests__/fixtures/empty-project/e2e-test-project-*
+**/e2e/__tests__/fixtures/empty-project/e2e-test-project-*
+storage
+htpasswd

packages/cli/src/commands/deploy.ts

@@ -1,22 +1,34 @@
 import * as api from '../rest/api'
+import { runtimes } from '../rest/api'
 import config from '../services/config'
 import prompts from 'prompts'
 import { Flags, ux } from '@oclif/core'
 import { AuthCommand } from './authCommand'
 import { parseProject } from '../services/project-parser'
 import { loadChecklyConfig } from '../services/checkly-config-loader'
-import { runtimes } from '../rest/api'
 import type { Runtime } from '../rest/runtimes'
 import {
-  Check, AlertChannelSubscription, AlertChannel, CheckGroup, Dashboard,
-  MaintenanceWindow, PrivateLocation, PrivateLocationCheckAssignment, PrivateLocationGroupAssignment,
-  Project, ProjectData, BrowserCheck,
+  AlertChannel,
+  AlertChannelSubscription,
+  BrowserCheck,
+  Check,
+  CheckGroup,
+  Dashboard,
+  MaintenanceWindow,
+  PrivateLocation,
+  PrivateLocationCheckAssignment,
+  PrivateLocationGroupAssignment,
+  Project,
+  ProjectData,
+  ProjectPayload,
 } from '../constructs'
 import chalk from 'chalk'
-import { splitConfigFilePath, getGitInformation } from '../services/util'
+import { getGitInformation, splitConfigFilePath } from '../services/util'
 import commonMessages from '../messages/common-messages'
 import { ProjectDeployResponse } from '../rest/projects'
 import { uploadSnapshots } from '../services/snapshot-service'
+import { DeployPreview } from '../services/deploy-preview'
+import { TableCli } from '../services/table-cli'
 
 // eslint-disable-next-line no-restricted-syntax
 enum ResourceDeployStatus {
@@ -136,7 +148,8 @@ export default class Deploy extends AuthCommand {
     try {
       const { data } = await api.projects.deploy({ ...projectPayload, repoInfo }, { dryRun: preview, scheduleOnDeploy })
       if (preview || output) {
-        this.log(this.formatPreview(data, project))
+        const preview = await this.formatPreview(data, project, projectPayload)
+        this.log(preview)
       }
       if (!preview) {
         await ux.wait(500)
@@ -161,7 +174,11 @@ export default class Deploy extends AuthCommand {
     }
   }
 
-  private formatPreview (previewData: ProjectDeployResponse, project: Project): string {
+  private async formatPreview (
+    previewData: ProjectDeployResponse,
+    project: Project,
+    projectPayload: ProjectPayload,
+  ): Promise<string> {
     // Current format of the data is: { checks: { logical-id-1: 'UPDATE' }, groups: { another-logical-id: 'CREATE' } }
     // We convert it into update: [{ logicalId, resourceType, construct }, ...], create: [], delete: []
     // This makes it easier to display.
@@ -257,10 +274,34 @@ export default class Deploy extends AuthCommand {
       output.push('')
     }
     if (sortedUpdating.length) {
+      const deployPreviewInst = new DeployPreview(projectPayload)
+      const deployPreviewDiff = await deployPreviewInst.getDiff()
+      const table = new TableCli<{
+        paramName: string;
+        currentValue: string;
+        newValue: string;
+      }>()
       output.push(chalk.bold.magenta('Update and Unchanged:'))
       for (const { logicalId, construct } of sortedUpdating) {
         output.push(`    ${construct.constructor.name}: ${logicalId}`)
       }
+      deployPreviewDiff.forEach((resource) => {
+        if (resource.diffResult) {
+          output.push(`    ${resource.resourceType}: ${resource.logicalId}`)
+          const outputTable = table.drawTable(
+            Object.entries(resource.diffResult).map(([key, value]) => {
+              return {
+                paramName: key,
+                currentValue: value?.[0] !== undefined ? String(value[0]) : '',
+                newValue: value?.[1] !== undefined ? String(value[1]) : '',
+              }
+            }),
+            ['paramName', 'currentValue', 'newValue'],
+            ['Param Name', 'Current Value', 'New Value'],
+          )
+          output.push(outputTable.join('\n'))
+        }
+      })
       output.push('')
     }
     if (skipping.length) {

packages/cli/src/constructs/project.ts

@@ -183,3 +183,8 @@ export class Session {
     return Session.privateLocations
   }
 }
+
+export type ProjectPayload = {
+  project: Pick<Project, 'logicalId' | 'name' | 'repoUrl'>
+  resources: ResourceSync[]
+}

packages/cli/src/rest/alert-channels.ts

@@ -0,0 +1,39 @@
+import type { AxiosInstance } from 'axios'
+
+interface Subscription {
+  id: number;
+  checkId: string;
+  activated: boolean;
+  groupId: string | null;
+}
+
+export interface AlertChannelApi {
+  id: number;
+  type: string;
+  config: {
+    number?: string;
+    address?: string;
+  };
+  created_at: string;
+  updated_at: string | null;
+  sendRecovery: boolean;
+  sendFailure: boolean;
+  sendDegraded: boolean;
+  sslExpiry: boolean;
+  sslExpiryThreshold: number;
+  autoSubscribe: boolean;
+  subscriptions: Subscription[];
+}
+
+class AlertChannels {
+  protected api: AxiosInstance
+  constructor (api: AxiosInstance) {
+    this.api = api
+  }
+
+  getAll () {
+    return this.api.get<AlertChannelApi[]>('/v1/alert-channels')
+  }
+}
+
+export default AlertChannels

packages/cli/src/rest/api.ts

@@ -13,6 +13,7 @@ import TestSessions from './test-sessions'
 import EnvironmentVariables from './environment-variables'
 import HeartbeatChecks from './heartbeat-checks'
 import ChecklyStorage from './checkly-storage'
+import AlertChannels from './alert-channels'
 
 export function getDefaults () {
   const apiKey = config.getApiKey()
@@ -100,3 +101,4 @@ export const testSessions = new TestSessions(api)
 export const environmentVariables = new EnvironmentVariables(api)
 export const heartbeatCheck = new HeartbeatChecks(api)
 export const checklyStorage = new ChecklyStorage(api)
+export const alertChannels = new AlertChannels(api)

packages/cli/src/rest/projects.ts

@@ -24,6 +24,7 @@ export interface ResourceSync {
   member: boolean,
   payload: any,
 }
+
 export interface ProjectSync {
   project: Project,
   resources: Array<ResourceSync>,

packages/cli/src/services/__tests__/__testcases__/compareobjectswithexistingkeys.case.ts

@@ -0,0 +1,38 @@
+export interface CompareObjectsWithExistingKeysCase {
+  input: {
+    obj1: object
+    obj2: object
+  }
+  expected: Record<string, [any, any]> | null
+}
+
+export const compareObjectsWithExistingKeysCases: CompareObjectsWithExistingKeysCase[] = [
+  {
+    input: {
+      obj1: { a: 1, b: { c: 2, d: 3 } },
+      obj2: { a: 1, b: { c: 2, d: 4 } },
+    },
+    expected: { 'b.d': [4, 3] },
+  },
+  {
+    input: {
+      obj1: { a: 1, b: 2 },
+      obj2: { a: 1, b: 3 },
+    },
+    expected: { b: [3, 2] },
+  },
+  {
+    input: {
+      obj1: { a: { b: { c: 1 } } },
+      obj2: { a: { b: { c: 2 } } },
+    },
+    expected: { 'a.b.c': [2, 1] },
+  },
+  {
+    input: {
+      obj1: { a: 1, b: 2 },
+      obj2: { a: 1, b: 2 },
+    },
+    expected: null,
+  },
+]

packages/cli/src/services/__tests__/__testcases__/uniqvalromarrbykey.case.ts

@@ -0,0 +1,43 @@
+export interface UniqValFromArrByKeyCase {
+  input: {
+    arr: any[]
+    key: string
+  }
+  expected: any[]
+}
+
+export const uniqValFromArrByKeyCases: UniqValFromArrByKeyCase[] = [
+  {
+    input: {
+      arr: [
+        { value1: 'alert-channel', id: 1 },
+        { value1: 'check', id: 2 },
+        { value1: 'alert-channel', id: 3 },
+      ],
+      key: 'value1',
+    },
+    expected: ['alert-channel', 'check'],
+  },
+  {
+    input: {
+      arr: [
+        { value2: 'A', value: 10 },
+        { value2: 'B', value: 20 },
+        { value2: 'A', value: 30 },
+      ],
+      key: 'value2',
+    },
+    expected: ['A', 'B'],
+  },
+  {
+    input: {
+      arr: [
+        { value2: 'A', value: 10 },
+        { value2: 'B', value: 20 },
+        { value2: 'A', value: 30 },
+      ],
+      key: 'value',
+    },
+    expected: [10, 20, 30],
+  },
+]

packages/cli/src/services/__tests__/util.spec.ts

@@ -1,5 +1,7 @@
 import * as path from 'path'
-import { pathToPosix, isFileSync } from '../util'
+import { pathToPosix, isFileSync, uniqValFromArrByKey, compareObjectsWithExistingKeys } from '../util'
+import { uniqValFromArrByKeyCases } from './__testcases__/uniqvalromarrbykey.case'
+import { compareObjectsWithExistingKeysCases } from './__testcases__/compareobjectswithexistingkeys.case'
 
 describe('util', () => {
   describe('pathToPosix()', () => {
@@ -21,4 +23,22 @@ describe('util', () => {
       expect(isFileSync('some random string')).toBeFalsy()
     })
   })
+
+  describe('uniqValFromArrByKey()', () => {
+    uniqValFromArrByKeyCases.forEach(({ input, expected }, index) => {
+      it(`should return unique values from array grouped by key for test case ${index + 1}`, () => {
+        const result = uniqValFromArrByKey(input.arr, input.key)
+        expect(result).toEqual(expected)
+      })
+    })
+  })
+
+  describe('compareObjectsWithExistingKeys()', () => {
+    compareObjectsWithExistingKeysCases.forEach(({ input, expected }, index) => {
+      it(`should compare objects and return differences for test case ${index + 1}`, () => {
+        const result = compareObjectsWithExistingKeys(input.obj1, input.obj2)
+        expect(result).toEqual(expected)
+      })
+    })
+  })
 })

packages/cli/src/services/deploy-preview.ts

@@ -0,0 +1,57 @@
+import * as api from '../rest/api'
+import { DiffResult, utilsService } from './util'
+import { ProjectData, ProjectPayload } from '../constructs'
+import { ResourceSync } from '../rest/projects'
+import { AlertChannelApi } from '../rest/alert-channels'
+
+export type ResourcesTypes = keyof ProjectData
+
+export interface DeployPreviewDiff {
+  resourceType: ResourcesTypes
+  logicalId: string
+  diffResult: DiffResult
+}
+
+export class DeployPreview {
+  readonly resources: ResourceSync[] = []
+  private serverStateAlertChannel: AlertChannelApi[] = []
+  constructor (projectPayload: ProjectPayload) {
+    this.resources = projectPayload.resources
+  }
+
+  private async getServerStateByResourceType (resourceType: ResourcesTypes) {
+    if (resourceType === 'alert-channel') {
+      const { data: serverStateAlertChannel } = await this.getAlertChannelsServerState()
+      this.serverStateAlertChannel = serverStateAlertChannel
+    }
+  }
+
+  public getUniqueResourceType (): string[] {
+    return utilsService.uniqValFromArrByKey(this.resources, 'type')
+  }
+
+  private getAlertChannelsServerState () {
+    return api.alertChannels.getAll()
+  }
+
+  private getResourcesAndServerStateDiff (resource: ResourceSync): DeployPreviewDiff {
+    let diffResult: DiffResult = null
+    if (resource.type === 'alert-channel' && this.serverStateAlertChannel.length) {
+      const serverStateItem = this.serverStateAlertChannel.find((item) => item.type === resource.payload.type)
+      if (serverStateItem) {
+        diffResult = utilsService.compareObjectsWithExistingKeys(resource.payload, serverStateItem)
+      }
+    }
+    return {
+      resourceType: resource.type as ResourcesTypes,
+      logicalId: resource.logicalId,
+      diffResult,
+    }
+  }
+
+  public async getDiff (): Promise<DeployPreviewDiff[]> {
+    const resourcesTypes = this.getUniqueResourceType() as ResourcesTypes[]
+    await Promise.all(resourcesTypes.map(this.getServerStateByResourceType.bind(this)))
+    return this.resources.map(this.getResourcesAndServerStateDiff.bind(this))
+  }
+}