@ossy/deployment-tools 0.0.40 → 0.0.42

package/package.json

@@ -1,31 +1,27 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.40",
+  "version": "0.0.42",
   "description": "Collection of scripts and tools to aid deployment of containers and static files to Amazon Web Services through GitHub Actions",
   "type": "module",
-  "types": "dist/index.d.ts" ,
   "main": "dist/index.js",
   "scripts": {
     "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "npm run build:public-exports && npm run build:cli",
-    "build:public-exports": "npx --yes @vercel/ncc build src/index.ts --source-map --out dist --license licenses.txt --minify",
-    "build:cli": "npx --yes @vercel/ncc build src/index.cli.ts --source-map --out bin --license licenses.txt --minify"
+    "build": "",
+    "build:docs": "jsdoc src/index.js"
   },
   "author": "Ossy",
   "license": "ISC",
-  "bin": "bin/index.js",
+  "bin": "dist/platform-cli.js",
   "dependencies": {
     "@actions/core": "^1.10.0",
     "@aws-sdk/client-sqs": "^3.186.0",
     "@aws-sdk/client-sts": "^3.188.0",
-    "@aws-sdk/types": "^3.193.0",
     "arg": "^5.0.2",
     "express": "^4.18.1",
     "nanoid": "^4.0.0",
-    "node-fetch": "^3.2.6",
-    "typescript": "^4.8.4"
+    "node-fetch": "^3.2.6"
   },
   "devDependencies": {
-    "@types/node": "^18.11.0"
+    "jsdoc": "^3.6.11"
   }
 }

package/src/{aws-credentials-client.ts → aws-credentials-client.js}

@@ -1,26 +1,25 @@
 import * as core from '@actions/core'
 import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
-import { DeploymentPlatform } from 'types'
-import { logInfo, logError } from 'log'
+import { logInfo, logError } from './log.js'
 
 export class AwsCredentialsClient {
 
-  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform) {
+  static resolveAwsCredentials(platformConfig) {
     // 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
-    if (!awsRoleToAssume) {
-      logInfo({ message: `[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package` })
+    if (!platformConfig.awsRoleToAssume) {
+      logInfo({ message: '[AwsCredentialsClient] No aws role to assume was found, leaving auth logic to @aws-sdk package' })
       return Promise.resolve(undefined)
     }
 
-    const stsClient = new STSClient({ region: awsRegion })
+    const stsClient = new STSClient({ region: platformConfig.awsRegion })
 
     logInfo({ message: '[AwsCredentialsClient] Fetching GitHub ID token' })
     return core.getIDToken('sts.amazonaws.com')
       .then(webIdentityToken => {
-        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${awsRoleToAssume}` })
+        logInfo({ message: `[AwsCredentialsClient] Attempting to resolve aws credentials by assuming the role: ${platformConfig.awsRoleToAssume}` })
         return stsClient.send(new AssumeRoleWithWebIdentityCommand({
-          RoleArn: `arn:aws:iam::${awsAccountId}:role/${awsRoleToAssume}`,
+          RoleArn: `arn:aws:iam::${platformConfig.awsAccountId}:role/${platformConfig.awsRoleToAssume}`,
           RoleSessionName: 'GitHubActions',
           DurationSeconds: 15 * 60,
           WebIdentityToken: webIdentityToken
@@ -33,7 +32,7 @@ export class AwsCredentialsClient {
         SecretAccessKey: responseData.Credentials.SecretAccessKey,
         accessKeyId: responseData.Credentials.AccessKeyId,
         sessionToken: responseData.Credentials.SessionToken,
-        secretAccessKey: responseData.Credentials.SecretAccessKey,
+        secretAccessKey: responseData.Credentials.SecretAccessKey
       }))
       .catch(error => {
         logError({ message: '[AwsCredentialsClient] Could not resolve temporary credentials', error })

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

@@ -1,6 +1,5 @@
 import fetch from 'node-fetch'
-import { logInfo, logError } from './log'
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+import { logInfo, logError } from './log.js'
 
 export const Matchers = {
   host: host => ({ host: [host] }),
@@ -20,13 +19,13 @@ const Handlers = {
 
 export class CaddyClient {
 
-  static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
+  static deploy(platformConfig, deploymentRequest) {
 
-    const url = `${deploymentRequest.subdomain}.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`
+    const url = `${deploymentRequest.subdomain}.${platformConfig.activeEnvironment}.${platformConfig.domain}`
 
     logInfo({ message: `[CaddyClient] Updating caddy config to route ${url} to localhost:${deploymentRequest.hostPort}` })
 
-    return fetch(`http://localhost:2019/config/apps/http/servers/${deploymentPlatform.ciServerName}/routes/0/handle`, {
+    return fetch(`http://localhost:2019/config/apps/http/servers/${platformConfig.ciServerName}/routes/0/handle`, {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(Handlers.subroute([
@@ -36,11 +35,11 @@ export class CaddyClient {
         }
       ]))
     })
-    .catch(error => logError({  message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
+      .catch(error => logError({ message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
   }
 
-  static applyDefaultServerConfig(deploymentPlatform: DeploymentPlatform) {
-    logInfo({  message: '[CaddyClient] Applying default caddy config' })
+  static applyDefaultServerConfig(platformConfig) {
+    logInfo({ message: '[CaddyClient] Applying default caddy config' })
     return fetch('http://localhost:2019/load', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
@@ -48,15 +47,15 @@ export class CaddyClient {
         apps: {
           http: {
             servers: {
-              [deploymentPlatform.ciServerName]: {
+              [platformConfig.ciServerName]: {
                 listen: [':80', ':443'],
                 routes: [
                   {
-                    match: [Matchers.host(`*.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`)],
+                    match: [Matchers.host(`*.${platformConfig.activeEnvironment}.${platformConfig.domain}`)],
                     handle: [Handlers.subroute([
                       {
-                        match: [Matchers.host(`${deploymentPlatform.ciSubDomain}.${deploymentPlatform.activeEnvironment}.${deploymentPlatform.domain}`)],
-                        handle: [Handlers.subroute([{ handle: [Handlers.reverseProxy(deploymentPlatform.ciInternalServerPort)]}])]
+                        match: [Matchers.host(`${platformConfig.ciSubDomain}.${platformConfig.activeEnvironment}.${platformConfig.domain}`)],
+                        handle: [Handlers.subroute([{ handle: [Handlers.reverseProxy(platformConfig.ciInternalServerPort)]}])]
                       }
                     ])],
                     terminal: true
@@ -69,7 +68,7 @@ export class CaddyClient {
             automation: {
               policies: [
                 {
-                  subjects:['*.qa.ossy.com'],
+                  subjects:[`*.${platformConfig.activeEnvironment}.${platformConfig.domain}`],
                   issuers:[
                     {
                       challenges:{
@@ -102,7 +101,7 @@ export class CaddyClient {
         }
       })
     })
-      .catch(error => logError({  message: '[CaddyClient] Could not apply default caddy config', error }))
+      .catch(error => logError({ message: '[CaddyClient] Could not apply default caddy config', error }))
   }
 
 }

package/src/{ci-rest-api.ts → ci-rest-api.js}

@@ -1,10 +1,9 @@
 import express from 'express'
-import { DeploymentPlatform } from 'types'
-import { logInfo } from './log'
+import { logInfo } from './log.js'
 
 export class CiRestApi {
 
-  static start(deploymentPlatform: DeploymentPlatform) {
+  static start(platformConfig) {
     const server = express()
 
     server.use(express.json())
@@ -17,8 +16,8 @@ export class CiRestApi {
       res.send('Server is live')
     })
 
-    server.listen(deploymentPlatform.ciInternalServerPort, () => {
-      logInfo({ message: `[ContainerManagerServer] API is live on port ${deploymentPlatform.ciInternalServerPort}`})
+    server.listen(platformConfig.ciInternalServerPort, () => {
+      logInfo({ message: `[ContainerManagerServer] API is live on port ${platformConfig.ciInternalServerPort}`})
     })
   }
 

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

@@ -0,0 +1,32 @@
+import arg from 'arg'
+import { logInfo } from '../log.js'
+import { PlatformClient } from '../platform-client.js'
+
+export const deployHandler = cliArgs => {
+  logInfo({ 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 })
+
+  PlatformClient.deploy({
+    username: parsedArgs['--username'],
+    authentication: parsedArgs['--authentication'],
+    targetEnvironment: parsedArgs['--target-env'],
+    pathToPlatformTemplates: parsedArgs['--platforms'],
+    pathToOssyFile: parsedArgs['--ossyfile']
+  })
+}

package/src/cli-commands/{index.ts → index.js}

@@ -1,8 +1,8 @@
-import { logError } from '../log'
-import { startHandler } from './start-handler'
-import { stopHandler } from './stop-handler'
-import { statusHandler } from './status-handler'
-import { deployHandler } from './deploy-handler'
+import { logError } from '../log.js'
+import { startHandler } from './start-handler.js'
+import { stopHandler } from './stop-handler.js'
+import { statusHandler } from './status-handler.js'
+import { deployHandler } from './deploy-handler.js'
 
 export const runCliCommand = ({ name, args }) => {
 

package/src/cli-commands/{start-handler.ts → start-handler.js}

@@ -1,10 +1,10 @@
 import arg from 'arg'
 import { platform } from 'os'
-import { logInfo, logError } from '../log'
-import { DeploymentPlatformClient } from 'deployment-platform-client'
+import { logInfo, logError } from '../log.js'
+import { PlatformClient } from '../platform-client.js'
 
 export const startHandler = cliArgs => {
-  logInfo({  message: 'Running start command' })
+  logInfo({ message: 'Running start command' })
 
   const Platforms = {
     windows: 'win32',
@@ -12,7 +12,7 @@ export const startHandler = cliArgs => {
   }
 
   if ([Platforms.windows].includes(platform())) {
-    return logError({  message: 'Deployment tools do not support this os' })
+    return logError({ message: 'Deployment tools do not support this os' })
   }
 
   const parsedArgs = arg({
@@ -20,5 +20,5 @@ export const startHandler = cliArgs => {
     '-p': '--platforms'
   }, { argv: cliArgs })
 
-  DeploymentPlatformClient.start(parsedArgs['--platforms'])
+  PlatformClient.start(parsedArgs['--platforms'])
 }

package/src/cli-commands/{status-handler.ts → status-handler.js}

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

package/src/cli-commands/{stop-handler.ts → stop-handler.js}

@@ -1,5 +1,5 @@
 import { exec } from 'child_process'
-import { logInfo } from '../log'
+import { logInfo } from '../log.js'
 
 export const stopHandler = () => {
   logInfo({ message: 'Running stop command' })

package/src/{deployment-queue-client.ts → deployment-queue-client.js}

@@ -4,19 +4,18 @@ import {
   DeleteMessageCommand,
   ReceiveMessageCommand
 } from '@aws-sdk/client-sqs'
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
-import { AwsCredentialsClient } from 'aws-credentials-client'
-import { logInfo, logError, logDebug } from 'log'
+import { AwsCredentialsClient } from './aws-credentials-client.js'
+import { logInfo, logError, logDebug } from './log.js'
 
 export class DeploymentQueueClient {
 
-  static sendDeploymentRequest(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
+  static sendDeploymentRequest(platformConfig, deploymentRequest) {
     logInfo({ message: '[DeploymentQueueClient] Starting deployment sequence' })
-    return DeploymentQueueClient.createAwsSqsClient(deploymentPlatform)
+    return DeploymentQueueClient.createAwsSqsClient(platformConfig)
       .then(sqsClient => {
 
         const sendMessageParams = {
-          QueueUrl: deploymentPlatform.awsDeploymentSqsArn,
+          QueueUrl: platformConfig.awsDeploymentSqsArn,
           MessageBody: JSON.stringify(deploymentRequest)
         }
 
@@ -30,44 +29,44 @@ export class DeploymentQueueClient {
 
   }
 
-  static pollForDeploymentRequests(deploymentPlatform: DeploymentPlatform, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
+  static pollForDeploymentRequests(platformConfig, handleDeploymentRequest) {
     logInfo({ message: '[DeploymentQueueClient] Starting polling for deployment requests' })
-    DeploymentQueueClient.createAwsSqsClient(deploymentPlatform).then(sqsClient => {
+    DeploymentQueueClient.createAwsSqsClient(platformConfig).then(sqsClient => {
       const FIVE_MINUTES = 3000
 
       setInterval(() => {
 
-        const receiveMessageCommand = new ReceiveMessageCommand({ QueueUrl: deploymentPlatform.awsDeploymentSqsArn })
+        const receiveMessageCommand = new ReceiveMessageCommand({ QueueUrl: platformConfig.awsDeploymentSqsArn })
 
         sqsClient.send(receiveMessageCommand)
           .then(data => data.Messages.map(message => {
 
-            logInfo({  message: '[DeploymentQueueClient] Received deployment request' })
+            logInfo({ message: '[DeploymentQueueClient] Received deployment request' })
 
             handleDeploymentRequest(JSON.parse(message.Body))
               .then(() => {
 
                 const deleteMessageCommand = new DeleteMessageCommand({
-                  QueueUrl: deploymentPlatform.awsDeploymentSqsArn,
+                  QueueUrl: platformConfig.awsDeploymentSqsArn,
                   ReceiptHandle: message.ReceiptHandle
                 })
 
                 sqsClient.send(deleteMessageCommand)
-                  .then(() => logInfo({  message: '[DeploymentQueueClient] Removing deployment request from queue' }))
-                  .catch(error => logError({  message: '[DeploymentQueueClient] Could not delete message from queue', error }))
+                  .then(() => logInfo({ message: '[DeploymentQueueClient] Removing deployment request from queue' }))
+                  .catch(error => logError({ message: '[DeploymentQueueClient] Could not delete message from queue', error }))
               })
 
           }))
-          .catch(error => logError({  message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
+          .catch(error => logError({ message: '[ContainerManagerServer] Could not handle incoming deployment request', error }))
       }, FIVE_MINUTES)
 
-      })
+    })
   }
 
-  static createAwsSqsClient(deploymentPlatform: DeploymentPlatform) {
-    return AwsCredentialsClient.resolveAwsCredentials(deploymentPlatform)
+  static createAwsSqsClient(platformConfig) {
+    return AwsCredentialsClient.resolveAwsCredentials(platformConfig)
       .then(awsCredentials => new SQSClient({
-        region: deploymentPlatform.awsRegion,
+        region: platformConfig.awsRegion,
         credentials: awsCredentials
       }))
   }

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

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

package/src/index.js

@@ -0,0 +1,3 @@
+export { PlatformClient } from './platform-client.js'
+export { PlatformTemplateService } from './platform-template.js'
+export { PlatformConfigService } from './platform-config.js'

package/src/{log/index.ts → log.js}

@@ -1,18 +1,18 @@
-interface LogInput {
-  type: TypeOfMessage;
-  message: string;
-  data?: any;
-  dataPrefix: string;
-}
+// interface LogInput {
+//   type: TypeOfMessage;
+//   message: string;
+//   data?: any;
+//   dataPrefix: string;
+// }
 
-enum TypeOfMessage {
-  Info = 'INFO',
-  Error = 'ERROR',
-  Debug = 'DEBUG'
+const TypeOfMessage = {
+  Info: 'INFO',
+  Error: 'ERROR',
+  Debug: 'DEBUG'
 }
 
 const log = (...params) => { console.log(...params) }
-const prefixTo = (prefix: string, message: string) => `[${prefix}]${message.startsWith('[') ? '' : ': '}`
+const prefixTo = (prefix, message) => `[${prefix}]${message.startsWith('[') ? '' : ': '}`
 
 export const logInfo = logInput => {
   const messagePrefix = prefixTo(TypeOfMessage.Info, logInput.message)

package/src/{index.cli.ts → platform-cli.js}

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

package/src/platform-client.js

@@ -0,0 +1,95 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import { SupportedDeploymentTypes } from './types.js'
+import { PlatformTemplateService } from './platform-template.js'
+import { PlatformConfigService } from './platform-config.js'
+import { CaddyClient } from './caddy-client.js'
+import { DockerClient } from './docker-client.js'
+import { DeploymentQueueClient } from './deployment-queue-client.js'
+import { CiRestApi } from './ci-rest-api.js'
+import { logError } from './log.js'
+
+// journalctl -u service-name.service
+export class PlatformClient {
+
+  static start(platformTemplatesFilePath) {
+    PlatformTemplateService.readFromFile(platformTemplatesFilePath).then(([firstPlatformTemplateFound]) => {
+      const platformConfig = PlatformConfigService.from(firstPlatformTemplateFound)
+
+      CiRestApi.start(platformConfig)
+      CaddyClient.applyDefaultServerConfig(platformConfig)
+
+      DeploymentQueueClient.pollForDeploymentRequests(
+        platformConfig,
+        deploymentRequest => {
+          DockerClient.deploy(platformConfig, deploymentRequest)
+          CaddyClient.deploy(platformConfig, deploymentRequest)
+          return Promise.resolve()
+        }
+      )
+
+    })
+      .catch(error => logError({ message: '[PlatformClient] Could not start the deployment platform', error }))
+  }
+
+  //eslint-disable-next-line max-params
+  static deploy({
+    username,
+    authentication,
+    targetEnvironment,
+    pathToPlatformTemplates,
+    pathToOssyFile
+  }) {
+
+    const platformConfigRequest = PlatformTemplateService.readFromFile(pathToPlatformTemplates)
+      .then(templates => templates.map(x => ({ ...x, activeEnvironment: targetEnvironment })))
+      .then(templates => templates.map(x => PlatformConfigService.from(x)))
+
+    const deploymentTemplatesRequest = PlatformClient.getDeploymentTemplates(pathToOssyFile)
+
+    return Promise.all([platformConfigRequest, deploymentTemplatesRequest])
+      .then(([platformConfigs, deploymentTemplates]) => {
+        deploymentTemplates.map(deploymentTemplate => {
+
+          const platformConfig = platformConfigs.find(config => config.platformName === deploymentTemplate.targetDeploymentPlatform)
+
+          if (!platformConfig) {
+            logError({ message: `[PlatformClient] 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) {
+            logError({ message: `[PlatformClient] Unsupported deployment type of ${deploymentTemplate.type}` })
+            return Promise.reject()
+          }
+
+          const deploymentRequest = {
+            ...deploymentTemplate,
+            env: PlatformClient.getEnvironmentVariables(targetEnvironment, deploymentTemplate),
+            username: username,
+            authentication: authentication
+          }
+
+          return DeploymentQueueClient.sendDeploymentRequest(platformConfig, deploymentRequest)
+
+        })
+      })
+      .catch(error => logError({ message: '[PlatformClient] Could not send deployment request', error }))
+  }
+
+  static getDeploymentTemplates(pathToOssyFile) {
+    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
+    return Promise.resolve(ossyfile.deployments || [])
+  }
+
+  static getEnvironmentVariables(targetEnvironment, deploymentRequest) {
+    const envs = deploymentRequest.env || {}
+    return {
+      ...(envs.shared || {}),
+      ...(envs[targetEnvironment] || {})
+    }
+  }
+
+}

package/src/platform-config.js

@@ -0,0 +1,34 @@
+import {
+  SupportedEnvironments,
+  SupportedRegions
+} from './types.js'
+
+export class PlatformConfigService {
+
+  static from(template) {
+
+    const withDefaults = {
+      platformName: SupportedEnvironments.LOCAL,
+      domain: 'localhost',
+      activeEnvironment: SupportedEnvironments.LOCAL,
+      supportedDeploymentTypes: ['CONTAINER'],
+      ciSubDomain: 'ci',
+      ciInternalServerPort: 3000,
+      ciServerName: 'ci-client',
+      ciDockerNetworkName: 'deployment-tools',
+      awsRegion: SupportedRegions.North,
+      ...template
+    }
+
+    const awsDeploymentSqsArn = `https://sqs.${withDefaults.awsRegion}.amazonaws.com/${withDefaults.awsAccountId}/${withDefaults.platformName}-${withDefaults.activeEnvironment}`
+    const awsRoleToAssume = process.env.CI ? 'github-ci-role' : undefined
+
+    return {
+      ...withDefaults,
+      awsDeploymentSqsArn,
+      awsRoleToAssume
+    }
+
+  }
+
+}