@ossy/deployment-tools 0.0.25 → 0.0.27

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.25",
+  "version": "0.0.27",
   "description": "Collection of scripts and tools to aid deployment of containers and static files",
   "main": "dist/index.js",
   "type": "module",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "npx --yes @vercel/ncc build src/index.js --out dist --license licenses.txt",
-    "build:esbuild": "npx --yes esbuild src/index.js --platform=node --bundle --outfile=dist/index.js"
+    "build": "npx --yes @vercel/ncc build src/index.ts --out dist --license licenses.txt",
+    "build:esbuild": "npx --yes esbuild src/index.ts --platform=node --bundle --outfile=dist/index.js"
   },
   "author": "Ossy",
   "license": "ISC",
@@ -19,6 +19,10 @@
     "arg": "^5.0.2",
     "express": "^4.18.1",
     "nanoid": "^4.0.0",
-    "node-fetch": "^3.2.6"
+    "node-fetch": "^3.2.6",
+    "typescript": "^4.8.4"
+  },
+  "devDependencies": {
+    "@types/node": "^18.11.0"
   }
 }

package/src/aws-credentials-client.ts

@@ -0,0 +1,32 @@
+import * as core from '@actions/core'
+import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
+import { DeploymentPlatform } from 'types'
+
+export class AwsCredentialsClient {
+
+  static resolveAwsCredentials(deploymentPlatform: DeploymentPlatform) {
+    // If awsRoleToAssume is present, then we assume we run in a github workflow
+    // If awsRoleToAssume is not present, then we assume they are resolved localy by aws-sdk
+    return deploymentPlatform.awsRoleToAssume
+      ? AwsCredentialsClient.getTemporaryCredentials(deploymentPlatform)
+      : Promise.resolve(undefined)
+  }
+
+  static getTemporaryCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform) {
+    const stsClient = new STSClient({ region: awsRegion })
+
+    return core.getIDToken('sts.amazonaws.com')
+      .then(webIdentityToken => stsClient.send(new AssumeRoleWithWebIdentityCommand({
+        RoleArn: `arn:aws:iam::${awsAccountId}:role/${awsRoleToAssume}`,
+        RoleSessionName: 'GitHubActions',
+        DurationSeconds: 15 * 60,
+        WebIdentityToken: webIdentityToken
+      })))
+      .then(responseData => ({
+        accessKeyId: responseData.Credentials.AccessKeyId,
+        secretAccessKey: responseData.Credentials.SecretAccessKey,
+        sessionToken: responseData.Credentials.SessionToken
+      }))
+  }
+
+}

package/src/{caddy-client.js → caddy-client.ts}

@@ -1,7 +1,6 @@
 import fetch from 'node-fetch'
-import { resolveConfiguration } from './config.js'
-
-const config = resolveConfiguration()
+import { log } from './log'
+import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
 
 export const Matchers = {
   host: host => ({ host: [host] }),
@@ -13,7 +12,7 @@ const Handlers = {
     handler: 'reverse_proxy',
     upstreams: [{ dial: `localhost:${upstreamPort}` }]
   }),
-  subroute: routes => ( {
+  subroute: routes => ({
     handler: 'subroute',
     routes
   })
@@ -21,28 +20,30 @@ const Handlers = {
 
 export class CaddyClient {
 
-  static new(serverName) {
-    return new CaddyClient(serverName)
-  }
+  static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
 
-  constructor(serverName = 'ci-client') {
-    this.serverName = serverName
-  }
+    const url = `${deploymentRequest.subdomain}.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`
+
+    log({
+      type: 'info',
+      message: `[CaddyClient] Updating caddy config to route ${url} to localhost:${deploymentRequest.hostPort}`
+    })
 
-  deploy({ domain, targetPort }) {
-    return fetch(`http://localhost:2019/config/apps/http/servers/${this.serverName}/routes/0/handle`, {
+    return fetch(`http://localhost:2019/config/apps/http/servers/${deploymentPlatform.ciServerName}/routes/0/handle`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify( Handlers.subroute([
+      body: JSON.stringify(Handlers.subroute([
         {
-          match: [Matchers.host(domain)],
-          handle: [Handlers.subroute([{ handle: [Handlers.reverseProxy(targetPort)]}])]
+          match: [Matchers.host(url)],
+          handle: [Handlers.subroute([{ handle: [Handlers.reverseProxy(deploymentRequest.hostPort)]}])]
         }
       ]))
     })
+    .catch(() => log({ type: 'error', message: `[CaddyClient] Could not update caddy config to include ${url}` }))
   }
 
-  applyDefaultServerConfig() {
+  static applyDefaultServerConfig(deploymentPlatform: DeploymentPlatform) {
+    log({ type: 'info', message: '[CaddyClient] Applying default caddy config' })
     return fetch('http://localhost:2019/load', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -50,12 +51,17 @@ export class CaddyClient {
         apps: {
           http: {
             servers: {
-              [this.serverName]: {
+              [deploymentPlatform.ciServerName]: {
                 listen: [':80', ':443'],
                 routes: [
                   {
-                    match: [Matchers.host(`*.${config.environmentName}.${config.domain}`)],
-                    handle: [],
+                    match: [Matchers.host(`*.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`)],
+                    handle: [Handlers.subroute([
+                      {
+                        match: [Matchers.host(`${deploymentPlatform.ciSubDomain}.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`)],
+                        handle: [Handlers.subroute([{ handle: [Handlers.reverseProxy(deploymentPlatform.ciInternalServerPort)]}])]
+                      }
+                    ])],
                     terminal: true
                   }
                 ]
@@ -99,6 +105,7 @@ export class CaddyClient {
         }
       })
     })
+      .catch(() => log({ type: 'error', message: '[CaddyClient] Could not apply default caddy config' }))
   }
 
 }

package/src/ci-rest-api.ts

@@ -0,0 +1,25 @@
+import express from 'express'
+import { DeploymentPlatform } from 'types'
+import { log } from './log'
+
+export class CiRestApi {
+
+  static start(deploymentPlatform: DeploymentPlatform) {
+    const server = express()
+
+    server.use(express.json())
+
+    server.get('/', (req, res) => {
+      res.redirect('/status')
+    })
+
+    server.get('/status', (req, res) => {
+      res.send('Server is live')
+    })
+
+    server.listen(deploymentPlatform.ciInternalServerPort, () => {
+      log({ type: 'info', message: `[ContainerManagerServer] API is live on port ${deploymentPlatform.ciInternalServerPort}`})
+    })
+  }
+
+}

package/src/cli-commands/deploy-handler.ts

@@ -0,0 +1,32 @@
+import arg from 'arg'
+import { log } from '../log'
+import { DeploymentPlatformClient } from 'deployment-platform-client'
+
+export const deployHandler = cliArgs => {
+  log({ type: 'info', message: 'Running deploy command' })
+
+  const parsedArgs = arg({
+    '--username': String,
+    '-u': '--username',
+
+    '--authentication': String,
+    '--a': '--authentication',
+
+    '--target-env': String,
+    '-t': '--target-env',
+
+    '--ossyfile': String,
+    '-o': '--ossyfile',
+
+    '--platforms': String,
+    '-p': '--platforms'
+  }, { argv: cliArgs })
+
+  DeploymentPlatformClient.deploy(
+    parsedArgs['--username'],
+    parsedArgs['--authentication'],
+    parsedArgs['--target-env'],
+    parsedArgs['--platforms'],
+    parsedArgs['--ossyfile']
+  )
+}

package/src/cli-commands/index.ts

@@ -0,0 +1,23 @@
+import { log } from '../log'
+import { startHandler } from './start-handler'
+import { stopHandler } from './stop-handler'
+import { statusHandler } from './status-handler'
+import { deployHandler } from './deploy-handler'
+
+export const runCliCommand = ({ name, args }) => {
+
+  if (!name) return log({ type: 'error', message: 'No command provided' })
+
+  const commandHandler = {
+    start: startHandler,
+    stop: stopHandler,
+    status: statusHandler,
+    deploy: deployHandler
+  }[name]
+
+  if (!commandHandler) {
+    return log({ type: 'error', message: 'Command not implemented, did you spell it correctly?' })
+  }
+
+  commandHandler(args)
+}

package/src/cli-commands/start-handler.ts

@@ -0,0 +1,24 @@
+import arg from 'arg'
+import { platform } from 'os'
+import { log } from '../log'
+import { DeploymentPlatformClient } from 'deployment-platform-client'
+
+export const startHandler = cliArgs => {
+  log({ type: 'info', message: 'Running start command' })
+
+  const Platforms = {
+    windows: 'win32',
+    mac: 'darwin'
+  }
+
+  if ([Platforms.windows].includes(platform())) {
+    return log({ type: 'error', message: 'Deployment tools do not support this os' })
+  }
+
+  const parsedArgs = arg({
+    '--platforms': String,
+    '-p': '--platforms'
+  }, { argv: cliArgs })
+
+  DeploymentPlatformClient.start(parsedArgs['--platforms'])
+}

package/src/cli-commands/status-handler.ts

@@ -0,0 +1,7 @@
+import { exec } from 'child_process'
+import { log } from '../log'
+
+export const statusHandler = () => {
+  log({ type: 'info', message: 'Running status command' })
+  exec('systemctl status deployment-tools.service')
+}

package/src/cli-commands/stop-handler.ts

@@ -0,0 +1,7 @@
+import { exec } from 'child_process'
+import { log } from '../log'
+
+export const stopHandler = () => {
+  log({ type: 'info', message: 'Running stop command' })
+  exec('systemctl stop deployment-tools.service')
+}

package/src/deployment-platform-client.ts

@@ -0,0 +1,140 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import {
+  DeploymentPlatform,
+  SupportedEnvironments,
+  ContainerDeploymentRequest,
+  DeploymentTemplate,
+  ContainerDeploymentTemplate,
+  SupportedDeploymentTypes
+} from 'types'
+import { CaddyClient } from './caddy-client'
+import { DockerClient } from './docker-client'
+import { DeploymentQueueClient } from './deployment-queue-client'
+import { CiRestApi } from './ci-rest-api'
+import { log } from 'log'
+
+export class DeploymentPlatformClient {
+
+  static start(pathToDeploymentPlatforms: string) {
+    DeploymentPlatformClient.getDeploymentPlatforms(pathToDeploymentPlatforms).then(([firstPlatformFound]) => {
+
+      if (!firstPlatformFound) {
+        log({ type: 'error', message: '[DeploymentPlatformClient] Could not find a deployment platform' })
+        return Promise.reject()
+      }
+
+      CiRestApi.start(firstPlatformFound)
+      CaddyClient.applyDefaultServerConfig(firstPlatformFound)
+
+      DeploymentQueueClient.pollForDeploymentRequests(
+        firstPlatformFound,
+        (deploymentRequest: ContainerDeploymentRequest) => {
+          DockerClient.deploy(firstPlatformFound, deploymentRequest)
+          CaddyClient.deploy(firstPlatformFound, deploymentRequest)
+          return Promise.resolve()
+        }
+      )
+
+    })
+    .catch(() => log({ type: 'error', message: '[DeploymentPlatformClient] Could not start the deployment platform' }))
+  }
+
+  //eslint-disable-next-line max-params
+  static deploy(
+    username,
+    authentication,
+    targetEnvironment,
+    pathToDeploymentPlatforms,
+    pathToOssyFile
+  ) {
+    return Promise.all([
+      DeploymentPlatformClient.getDeploymentPlatforms(pathToDeploymentPlatforms),
+      DeploymentPlatformClient.getDeploymentTemplates(pathToOssyFile)
+    ])
+      .then(([platforms, deploymentTemplates]) => {
+        deploymentTemplates.map(deploymentTemplate => {
+
+          log({
+            type: 'info',
+            message: `[DeploymentPlatformClient]: Found deployment platforms [${platforms.join(', ')}]`
+          })
+
+          const deploymentPlatform = platforms.find(platform => platform.platformName === deploymentTemplate.targetDeploymentPlatform)
+
+          if (!deploymentPlatform) {
+            log({ type: 'error', message: `[DeploymentPlatformClient] Could not find a deployment platform with the name ${deploymentTemplate.targetDeploymentPlatform}` })
+            return Promise.reject()
+          }
+
+          process.env.NODE_TLS_REJECT_UNAUTHORIZED = '0'
+
+          if (deploymentTemplate.type !== SupportedDeploymentTypes.Container) {
+            log({ type: 'error', message: `[DeploymentPlatformClient] Unsupported deployment type of ${deploymentTemplate.type}` })
+            return Promise.reject()
+          }
+
+          const deploymentRequest: ContainerDeploymentRequest = {
+            ...deploymentTemplate as ContainerDeploymentTemplate,
+            env: DeploymentPlatformClient.getEnvironmentVariables(targetEnvironment, deploymentTemplate),
+            username: username,
+            authentication: authentication
+          }
+
+          return DeploymentQueueClient.sendDeploymentRequest(deploymentPlatform, deploymentRequest)
+
+        })
+      })
+      .catch(error => console.log(error))
+  }
+
+  static getDeploymentTemplates(pathToOssyFile: string): Promise<DeploymentTemplate[]> {
+    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
+    return Promise.resolve(ossyfile.deployments || [])
+  }
+
+  static getDeploymentPlatforms(pathToDeploymentPlatforms: string): Promise<DeploymentPlatform[]> {
+    let deploymentPlatforms = JSON.parse(readFileSync(resolve(pathToDeploymentPlatforms), 'utf8'))
+
+    if (!Array.isArray(deploymentPlatforms)) {
+      deploymentPlatforms = [deploymentPlatforms]
+    }
+
+    return Promise.resolve((deploymentPlatforms || []).map(DeploymentPlatformClient.resolveDeploymentPlatformValues))
+  }
+
+  static getEnvironmentVariables(targetEnvironment: SupportedEnvironments, deploymentRequest: DeploymentTemplate) {
+    const envs = deploymentRequest.env || {}
+    return {
+      ...(envs.shared || {}),
+      ...(envs[targetEnvironment] || {})
+    }
+  }
+
+  static resolveDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform {
+    return DeploymentPlatformClient.setCalculatedDeploymentPlatformValues(DeploymentPlatformClient.setDefaultDeploymentPlatformValues(deploymentPlatform))
+  }
+
+  static setDefaultDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform {
+    return {
+      platformName: SupportedEnvironments.LOCAL,
+      domain: 'localhost',
+      activeEnvironment: SupportedEnvironments.LOCAL,
+      supportedDeploymentTypes: ['CONTAINER'],
+      ciSubDomain: 'ci',
+      ciInternalServerPort: 3000,
+      ciServerName: 'ci-client',
+      ciDockerNetworkName: 'deployment-tools',
+      // awsRoleToAssume: 'github-ci-role',
+      ...deploymentPlatform
+    }
+  }
+
+  static setCalculatedDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform {
+    return {
+      awsDeploymentSqsArn: `https://sqs.${deploymentPlatform.awsRegion}.amazonaws.com/${deploymentPlatform.awsAccountId}/${deploymentPlatform.platformName}-${deploymentPlatform.activeEnvironment}`,
+      ...deploymentPlatform
+    }
+  }
+
+}

package/src/deployment-queue-client.ts

@@ -0,0 +1,73 @@
+import {
+  SQSClient,
+  SendMessageCommand,
+  DeleteMessageCommand,
+  ReceiveMessageCommand
+} from '@aws-sdk/client-sqs'
+import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+import { AwsCredentialsClient } from 'aws-credentials-client'
+import { log } from 'log'
+
+export class DeploymentQueueClient {
+
+  static sendDeploymentRequest(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
+    log({ type: 'info', message: '[DeploymentQueueClient] Sending deployment request...' })
+    return DeploymentQueueClient.createAwsSqsClient(deploymentPlatform)
+      .then(sqsClient => {
+
+        const command = new SendMessageCommand({
+          QueueUrl: deploymentPlatform.awsDeploymentSqsArn,
+          MessageBody: JSON.stringify(deploymentRequest)
+        })
+
+        return sqsClient.send(command)
+          .then(() => log({ type: 'info', message: '[DeploymentQueueClient] Deployment request sent' }))
+          .catch(() => log({ type: 'error', message: '[DeploymentQueueClient] Could not send deployment request' }))
+
+      })
+
+  }
+
+  static pollForDeploymentRequests(deploymentPlatform: DeploymentPlatform, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
+    log({ type: 'info', message: '[DeploymentQueueClient] Starting polling for deployment requests' })
+    DeploymentQueueClient.createAwsSqsClient(deploymentPlatform).then(sqsClient => {
+      const FIVE_MINUTES = 3000
+
+      setInterval(() => {
+
+        const receiveMessageCommand = new ReceiveMessageCommand({ QueueUrl: deploymentPlatform.awsDeploymentSqsArn })
+
+        sqsClient.send(receiveMessageCommand)
+          .then(data => data.Messages.map(message => {
+
+            log({ type: 'info', message: '[DeploymentQueueClient] Received deployment request' })
+
+            handleDeploymentRequest(JSON.parse(message.Body))
+              .then(() => {
+
+                const deleteMessageCommand = new DeleteMessageCommand({
+                  QueueUrl: deploymentPlatform.awsDeploymentSqsArn,
+                  ReceiptHandle: message.ReceiptHandle
+                })
+
+                sqsClient.send(deleteMessageCommand)
+                  .then(() => log({ type: 'info', message: '[DeploymentQueueClient] Removing deployment request from queue' }))
+                  .catch(() => log({ type: 'error', message: '[DeploymentQueueClient] Removing deployment request from queue' }))
+              })
+
+          }))
+          .catch(() => log({ type: 'error', message: '[ContainerManagerServer] Could not handle incoming deployment request' }))
+      }, FIVE_MINUTES)
+
+      })
+  }
+
+  static createAwsSqsClient(deploymentPlatform: DeploymentPlatform) {
+    return AwsCredentialsClient.resolveAwsCredentials(deploymentPlatform)
+      .then(awsCredentials => new SQSClient({
+        region: deploymentPlatform.awsRegion,
+        credentials: awsCredentials
+      }))
+  }
+
+}

package/src/docker-client.ts

@@ -0,0 +1,80 @@
+import { exec } from 'child_process'
+import fs from 'fs'
+import { nanoid } from 'nanoid'
+import path from 'path'
+import { fileURLToPath } from 'url'
+import { log } from './log'
+import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+
+const __filename = fileURLToPath(import.meta.url)
+const __dirname = path.dirname(__filename)
+
+export class DockerClient {
+
+  static createDockerNetworkForContainerManagerServer(deploymentPlatform: DeploymentPlatform) {
+    log({ type: 'info', message: '[DockerClient] Creating docker network for comunication between containers' })
+    exec(`sudo docker network create ${deploymentPlatform.ciDockerNetworkName}`)
+  }
+
+  static stopContainer(deploymentRequest: ContainerDeploymentRequest) {
+    const name = deploymentRequest.image.replaceAll('/', '_')
+    log({ type: 'info', message: `Running docker stop for image with the name of ${name}` })
+    return `sudo docker stop ${name} ||`
+  }
+
+  static startContainer(deploymentPlatform, { image, containerPort, hostPort, registry, env }: ContainerDeploymentRequest) {
+    const name = image.replaceAll('/', '_')
+    const imageUrl = !!registry ? `${registry}/${image}` : image
+    const envsAsString = Object.entries(env || {}).reduce((envs, [name, value]) => `${envs} --env ${name}=${value}`, '')
+    log({ type: 'info', message: `Running docker start for image with the name of ${name} with port mapping ${hostPort}:${containerPort} and source ${imageUrl}` })
+    return `sudo docker run -d -p ${hostPort}:${containerPort} --name=${name} --network=${deploymentPlatform.ciDockerNetworkName} --network-alias=${name} --rm ${envsAsString} ${imageUrl}`
+  }
+
+  static resolveCredentials({ registry, username, authentication }: ContainerDeploymentRequest) {
+    const shouldAuthenticate = username || authentication
+
+    if (!shouldAuthenticate) {
+      log({ type: 'info', message: 'No docker credentials provided, assuming image is publicly hosted' })
+      return ''
+    }
+
+    log({ type: 'info', message: `Resolving docker credentials for ${registry}` })
+    return `sudo docker login ${registry} -u ${username} -p ${authentication}`
+  }
+
+  static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest): Promise<void> {
+    return new Promise(resolve => {
+      log({ type: 'info', message: 'Starting docker deployment sequence' })
+
+      const dockerCommandScript = `'#!/bin/bash'
+${DockerClient.stopContainer(deploymentRequest)}
+${DockerClient.resolveCredentials(deploymentRequest)}
+${DockerClient.startContainer(deploymentPlatform, deploymentRequest)}`
+
+      const deploymentId = nanoid()
+
+      const FilePaths = {
+        DeploymentScript: `${__dirname}/${deploymentId}.sh`
+      }
+
+      fs.writeFileSync(FilePaths.DeploymentScript, dockerCommandScript)
+      const command = exec(`bash ${FilePaths.DeploymentScript}`)
+
+      command.stdout.on('data', data => {
+        log({ type: 'info', message: `[DockerClient]: ${data}` })
+      })
+
+      command.stderr.on('data', (data) => {
+        log({ type: 'error', message: `[DockerClient]: ${data}` })
+      })
+
+      command.on('close', code => {
+        log({ type: 'info', message: `[DockerClient] command exited with code ${code}` })
+        fs.unlinkSync(FilePaths.DeploymentScript)
+        resolve()
+      })
+    })
+
+  }
+
+}

package/src/index.ts

@@ -0,0 +1,7 @@
+#!/usr/bin/env node
+import { runCliCommand } from './cli-commands/index'
+
+//eslint-disable-next-line no-unused-vars
+const [_, __, command, ...restArgs] = process.argv
+
+runCliCommand({ name: command, args: restArgs })

package/src/log/index.ts

@@ -0,0 +1,4 @@
+export const log = ({ type, message } = { type: 'info', message: '' }) => {
+  const messagePrefix = `[${type.toUpperCase()}]${message.startsWith('[') ? '' : ': '}`
+  console.log(`${messagePrefix}${message}`)
+}

package/src/types/index.ts

@@ -0,0 +1,65 @@
+export interface DeploymentPlatformTemplate {
+  platformName: string;
+  domain: string;
+  supportedDeploymentTypes: SupportedDeploymentTypes[];
+  supportedEnvironments: SupportedEnvironments[];
+  awsRegion: string;
+  awsAccountId: string;
+  awsKeyPairName?: string;
+  awsRoleToAssume?: string;
+  awsDeploymentSqsArn?: string;
+  ciSubDomain?: string;
+  ciInternalServerPort?: string | number;
+  ciServerName?: string;
+  ciDockerNetworkName?: string;
+}
+
+export interface DeploymentPlatform extends Required<Omit<DeploymentPlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
+  activeEnvironment: SupportedEnvironments;
+  awsRoleToAssume?: string;
+  awsKeyPairName?: string;
+}
+
+export enum SupportedRegions {
+  North = 'eu-north-1'
+}
+
+export enum SupportedEnvironments {
+  LOCAL = 'local',
+  QA = 'qa',
+  TEST = 'test',
+  DEMO = 'demo',
+  PROD = 'prod'
+}
+
+export enum SupportedDeploymentTypes {
+  Container = 'CONTAINER',
+  // Static = 'STATIC'
+}
+
+export interface DeploymentTemplate {
+  type: SupportedDeploymentTypes;
+  targetDeploymentPlatform: string;
+  subdomain?: string;
+  env?: {
+    shared?: { [name: string]: string | number };
+    prod?: { [name: string]: string | number };
+    test?: { [name: string]: string | number };
+    qa?: { [name: string]: string | number };
+  }
+}
+
+export interface ContainerDeploymentTemplate extends DeploymentTemplate {
+  type: SupportedDeploymentTypes.Container;
+  dockerFile: string;
+  dockerContext: string;
+  image: string;
+  hostPort: number;
+  containerPort: number;
+  registry: string;
+}
+
+export interface ContainerDeploymentRequest extends ContainerDeploymentTemplate {
+  authentication?: string;
+  username?: string;
+}

package/tsconfig.json

@@ -0,0 +1,9 @@
+{
+  "compilerOptions": {
+    "target": "es2015",
+    "module": "ESNext",
+    "moduleResolution": "nodenext",
+    "baseUrl": "src",
+    "lib": ["es2021"]
+  }
+}