@ossy/deployment-tools 0.0.39 → 0.0.41

package/dist/platform-client.d.ts

@@ -0,0 +1,13 @@
+import { SupportedEnvironments, DeploymentTemplate } from 'types';
+export declare class PlatformClient {
+    static start(platformTemplatesFilePath: string): void;
+    static deploy({ username, authentication, targetEnvironment, pathToPlatformTemplates, pathToOssyFile }: {
+        username: any;
+        authentication: any;
+        targetEnvironment: any;
+        pathToPlatformTemplates: any;
+        pathToOssyFile: any;
+    }): Promise<void>;
+    static getDeploymentTemplates(pathToOssyFile: string): Promise<DeploymentTemplate[]>;
+    static getEnvironmentVariables(targetEnvironment: SupportedEnvironments, deploymentRequest: DeploymentTemplate): any;
+}

package/dist/platform-config.d.ts

@@ -0,0 +1,4 @@
+import { PlatformConfig, PlatformTemplate } from 'types';
+export declare class PlatformConfigService {
+    static from(template: PlatformTemplate): PlatformConfig;
+}

package/dist/platform-template.d.ts

@@ -0,0 +1,5 @@
+import { PlatformTemplate } from 'types';
+export declare class PlatformTemplateService {
+    static readFromFile(path: string): Promise<PlatformTemplate[]>;
+    static fakeValidateTemplate(obj: any): PlatformTemplate;
+}

package/dist/types/index.d.ts

@@ -1,4 +1,4 @@
-export interface DeploymentPlatformTemplate {
+export interface PlatformTemplate {
     platformName: string;
     domain: string;
     supportedDeploymentTypes: SupportedDeploymentTypes[];
@@ -13,7 +13,7 @@ export interface DeploymentPlatformTemplate {
     ciServerName?: string;
     ciDockerNetworkName?: string;
 }
-export interface DeploymentPlatform extends Required<Omit<DeploymentPlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
+export interface PlatformConfig extends Required<Omit<PlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
     activeEnvironment: SupportedEnvironments;
     awsRoleToAssume?: string;
     awsKeyPairName?: string;

package/{bin/dist/types/index.d.ts → dist/types.d.ts}

@@ -1,4 +1,4 @@
-export interface DeploymentPlatformTemplate {
+export interface PlatformTemplate {
     platformName: string;
     domain: string;
     supportedDeploymentTypes: SupportedDeploymentTypes[];
@@ -13,7 +13,7 @@ export interface DeploymentPlatformTemplate {
     ciServerName?: string;
     ciDockerNetworkName?: string;
 }
-export interface DeploymentPlatform extends Required<Omit<DeploymentPlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
+export interface PlatformConfig extends Required<Omit<PlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
     activeEnvironment: SupportedEnvironments;
     awsRoleToAssume?: string;
     awsKeyPairName?: string;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ossy/deployment-tools",
-  "version": "0.0.39",
+  "version": "0.0.41",
   "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" ,
@@ -9,7 +9,7 @@
     "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:cli": "npx --yes @vercel/ncc build src/platform-cli.ts --source-map --out bin --license licenses.txt --minify"
   },
   "author": "Ossy",
   "license": "ISC",

package/src/aws-credentials-client.ts

@@ -1,11 +1,11 @@
 import * as core from '@actions/core'
 import { STSClient, AssumeRoleWithWebIdentityCommand } from '@aws-sdk/client-sts'
-import { DeploymentPlatform } from 'types'
+import { PlatformConfig } from 'types'
 import { logInfo, logError } from 'log'
 
 export class AwsCredentialsClient {
 
-  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform) {
+  static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: 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) {

package/src/caddy-client.ts

@@ -1,6 +1,6 @@
 import fetch from 'node-fetch'
 import { logInfo, logError } from './log'
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+import { PlatformConfig, ContainerDeploymentRequest } from 'types'
 
 export const Matchers = {
   host: host => ({ host: [host] }),
@@ -20,13 +20,13 @@ const Handlers = {
 
 export class CaddyClient {
 
-  static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
+  static deploy(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest) {
 
-    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([
@@ -39,7 +39,7 @@ export class CaddyClient {
     .catch(error => logError({  message: `[CaddyClient] Could not update caddy config to include ${url}`, error }))
   }
 
-  static applyDefaultServerConfig(deploymentPlatform: DeploymentPlatform) {
+  static applyDefaultServerConfig(platformConfig: PlatformConfig) {
     logInfo({  message: '[CaddyClient] Applying default caddy config' })
     return fetch('http://localhost:2019/load', {
       method: 'POST',
@@ -48,15 +48,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 +69,7 @@ export class CaddyClient {
             automation: {
               policies: [
                 {
-                  subjects:['*.qa.ossy.com'],
+                  subjects:[`*.${platformConfig.activeEnvironment}.${platformConfig.domain}`],
                   issuers:[
                     {
                       challenges:{

package/src/ci-rest-api.ts

@@ -1,10 +1,10 @@
 import express from 'express'
-import { DeploymentPlatform } from 'types'
+import { PlatformConfig } from 'types'
 import { logInfo } from './log'
 
 export class CiRestApi {
 
-  static start(deploymentPlatform: DeploymentPlatform) {
+  static start(platformConfig: PlatformConfig) {
     const server = express()
 
     server.use(express.json())
@@ -17,8 +17,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.ts

@@ -1,9 +1,9 @@
 import arg from 'arg'
-import { logInfo } from '../log'
-import { DeploymentPlatformClient } from 'deployment-platform-client'
+import { logInfo } from 'log'
+import { PlatformClient } from 'platform-client'
 
 export const deployHandler = cliArgs => {
-  logInfo({  message: 'Running deploy command' })
+  logInfo({ message: 'Running deploy command' })
 
   const parsedArgs = arg({
     '--username': String,
@@ -22,11 +22,11 @@ export const deployHandler = cliArgs => {
     '-p': '--platforms'
   }, { argv: cliArgs })
 
-  DeploymentPlatformClient.deploy(
-    parsedArgs['--username'],
-    parsedArgs['--authentication'],
-    parsedArgs['--target-env'],
-    parsedArgs['--platforms'],
-    parsedArgs['--ossyfile']
-  )
+  PlatformClient.deploy({
+    username: parsedArgs['--username'],
+    authentication: parsedArgs['--authentication'],
+    targetEnvironment: parsedArgs['--target-env'],
+    pathToPlatformTemplates: parsedArgs['--platforms'],
+    pathToOssyFile: parsedArgs['--ossyfile']
+  })
 }

package/src/cli-commands/index.ts

@@ -1,4 +1,4 @@
-import { logError } from '../log'
+import { logError } from 'log'
 import { startHandler } from './start-handler'
 import { stopHandler } from './stop-handler'
 import { statusHandler } from './status-handler'

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

@@ -1,10 +1,10 @@
 import arg from 'arg'
 import { platform } from 'os'
 import { logInfo, logError } from '../log'
-import { DeploymentPlatformClient } from 'deployment-platform-client'
+import { PlatformClient } from 'platform-client'
 
 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

@@ -1,7 +1,7 @@
 import { exec } from 'child_process'
-import { logInfo } from '../log'
+import { logInfo } from 'log'
 
 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

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

package/src/deployment-queue-client.ts

@@ -4,19 +4,19 @@ import {
   DeleteMessageCommand,
   ReceiveMessageCommand
 } from '@aws-sdk/client-sqs'
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+import { PlatformConfig, ContainerDeploymentRequest } from 'types'
 import { AwsCredentialsClient } from 'aws-credentials-client'
 import { logInfo, logError, logDebug } from 'log'
 
 export class DeploymentQueueClient {
 
-  static sendDeploymentRequest(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest) {
+  static sendDeploymentRequest(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest) {
     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 +30,44 @@ export class DeploymentQueueClient {
 
   }
 
-  static pollForDeploymentRequests(deploymentPlatform: DeploymentPlatform, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
+  static pollForDeploymentRequests(platformConfig: PlatformConfig, handleDeploymentRequest: (deploymentRequest: ContainerDeploymentRequest) => Promise<void>) {
     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: PlatformConfig) {
+    return AwsCredentialsClient.resolveAwsCredentials(platformConfig)
       .then(awsCredentials => new SQSClient({
-        region: deploymentPlatform.awsRegion,
+        region: platformConfig.awsRegion,
         credentials: awsCredentials
       }))
   }

package/src/docker-client.ts

@@ -4,16 +4,16 @@ import { nanoid } from 'nanoid'
 import path from 'path'
 import { fileURLToPath } from 'url'
 import { logInfo, logError } from './log'
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types'
+import { PlatformConfig, ContainerDeploymentRequest } from 'types'
 
 const __filename = fileURLToPath(import.meta.url)
 const __dirname = path.dirname(__filename)
 
 export class DockerClient {
 
-  static createDockerNetworkForContainerManagerServer(deploymentPlatform: DeploymentPlatform) {
+  static createDockerNetworkForContainerManagerServer(platformConfig: PlatformConfig) {
     logInfo({  message: '[DockerClient] Creating docker network for comunication between containers' })
-    exec(`sudo docker network create ${deploymentPlatform.ciDockerNetworkName}`)
+    exec(`sudo docker network create ${platformConfig.ciDockerNetworkName}`)
   }
 
   static stopContainer(deploymentRequest: ContainerDeploymentRequest) {
@@ -22,12 +22,12 @@ export class DockerClient {
     return `sudo docker stop ${name} ||`
   }
 
-  static startContainer(deploymentPlatform, { image, containerPort, hostPort, registry, env }: ContainerDeploymentRequest) {
+  static startContainer(platformConfig: PlatformConfig, { 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}`, '')
     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}`
+    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) {
@@ -42,14 +42,14 @@ export class DockerClient {
     return `sudo docker login ${registry} -u ${username} -p ${authentication}`
   }
 
-  static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest): Promise<void> {
+  static deploy(platformConfig: PlatformConfig, deploymentRequest: ContainerDeploymentRequest): Promise<void> {
     return new Promise(resolve => {
       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()
 

package/src/index.d.ts

@@ -0,0 +1,2 @@
+export { PlatformClient } from 'platform-client';
+export * from 'types';

package/src/index.ts

@@ -1,2 +1,4 @@
-export { DeploymentPlatformClient } from 'deployment-platform-client'
 export * from 'types'
+export { PlatformClient } from 'platform-client'
+export { PlatformTemplateService } from 'platform-template'
+export { PlatformConfigService } from 'platform-config'

package/src/platform-client.ts

@@ -0,0 +1,102 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import {
+  SupportedEnvironments,
+  ContainerDeploymentRequest,
+  DeploymentTemplate,
+  ContainerDeploymentTemplate,
+  SupportedDeploymentTypes
+} from 'types'
+import { PlatformTemplateService } from 'platform-template'
+import { PlatformConfigService } from 'platform-config'
+import { CaddyClient } from './caddy-client'
+import { DockerClient } from './docker-client'
+import { DeploymentQueueClient } from './deployment-queue-client'
+import { CiRestApi } from './ci-rest-api'
+import { logInfo, logError } from 'log'
+
+
+// journalctl -u service-name.service
+export class PlatformClient {
+
+  static start(platformTemplatesFilePath: string) {
+    PlatformTemplateService.readFromFile(platformTemplatesFilePath).then(([firstPlatformTemplateFound]) => {
+      const platformConfig = PlatformConfigService.from(firstPlatformTemplateFound)
+
+      CiRestApi.start(platformConfig)
+      CaddyClient.applyDefaultServerConfig(platformConfig)
+
+      DeploymentQueueClient.pollForDeploymentRequests(
+        platformConfig,
+        (deploymentRequest: ContainerDeploymentRequest) => {
+          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: ContainerDeploymentRequest = {
+            ...deploymentTemplate as ContainerDeploymentTemplate,
+            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: string): Promise<DeploymentTemplate[]> {
+    const ossyfile = JSON.parse(readFileSync(resolve(pathToOssyFile), 'utf8'))
+    return Promise.resolve(ossyfile.deployments || [])
+  }
+
+  static getEnvironmentVariables(targetEnvironment: SupportedEnvironments, deploymentRequest: DeploymentTemplate) {
+    const envs = deploymentRequest.env || {}
+    return {
+      ...(envs.shared || {}),
+      ...(envs[targetEnvironment] || {})
+    }
+  }
+
+}

package/src/platform-config.ts

@@ -0,0 +1,36 @@
+import {
+  PlatformConfig,
+  PlatformTemplate,
+  SupportedEnvironments,
+  SupportedRegions
+} from 'types'
+
+export class PlatformConfigService {
+
+  static from(template: PlatformTemplate): PlatformConfig {
+
+    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
+    }
+
+  }
+
+}

package/src/platform-template.ts

@@ -0,0 +1,31 @@
+import { resolve } from 'path'
+import { readFileSync } from 'fs'
+import { PlatformTemplate } from 'types'
+import { logError, logInfo } from 'log'
+
+export class PlatformTemplateService {
+
+  static readFromFile(path: string): Promise<PlatformTemplate[]> {
+    const fileData = readFileSync(resolve(path), 'utf8')
+
+    if (!fileData && typeof fileData !== 'string') {
+      logError({ message: `[DeploymentPlatformClient] Could not find a deployment platform at ${path}` })
+      return Promise.reject()
+    }
+
+    let potentialTemplates = JSON.parse(fileData)
+
+    if (!Array.isArray(potentialTemplates)) {
+      potentialTemplates = [potentialTemplates]
+    }
+
+    const templates = potentialTemplates.map(PlatformTemplateService.fakeValidateTemplate)
+    logInfo({ message: `[PlatformTemplateService]: Found platforms [${templates.map(x => x.platformName).join(', ')}]` })
+    return Promise.resolve(templates)
+  }
+
+  static fakeValidateTemplate(obj: any): PlatformTemplate {
+    // todo: implement real one
+    return obj
+  }
+}

package/src/{types/index.ts → types.ts}

@@ -1,4 +1,4 @@
-export interface DeploymentPlatformTemplate {
+export interface PlatformTemplate {
   platformName: string;
   domain: string;
   supportedDeploymentTypes: SupportedDeploymentTypes[];
@@ -14,7 +14,7 @@ export interface DeploymentPlatformTemplate {
   ciDockerNetworkName?: string;
 }
 
-export interface DeploymentPlatform extends Required<Omit<DeploymentPlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
+export interface PlatformConfig extends Required<Omit<PlatformTemplate, 'awsRoleToAssume' | 'awsKeyPairName'>> {
   activeEnvironment: SupportedEnvironments;
   awsRoleToAssume?: string;
   awsKeyPairName?: string;

package/tsconfig.json

@@ -5,7 +5,6 @@
     "moduleResolution": "nodenext",
     "baseUrl": "src",
     "lib": ["es2021"],
-    "declaration": true,
-    "declarationDir": "./dist"
+    "declaration": true
   }
 }

package/bin/deployment-platform-client.d.ts

@@ -1,11 +0,0 @@
-import { DeploymentPlatform, SupportedEnvironments, DeploymentTemplate } from 'types';
-export declare class DeploymentPlatformClient {
-    static start(pathToDeploymentPlatforms: string): void;
-    static deploy(username: any, authentication: any, targetEnvironment: any, pathToDeploymentPlatforms: any, pathToOssyFile: any): Promise<void>;
-    static getDeploymentTemplates(pathToOssyFile: string): Promise<DeploymentTemplate[]>;
-    static getDeploymentPlatforms(pathToDeploymentPlatforms: string): Promise<DeploymentPlatform[]>;
-    static getEnvironmentVariables(targetEnvironment: SupportedEnvironments, deploymentRequest: DeploymentTemplate): any;
-    static resolveDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform;
-    static setDefaultDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform;
-    static setCalculatedDeploymentPlatformValues(deploymentPlatform: DeploymentPlatform): DeploymentPlatform;
-}

package/bin/dist/aws-credentials-client.d.ts

@@ -1,4 +0,0 @@
-import { DeploymentPlatform } from 'types';
-export declare class AwsCredentialsClient {
-    static resolveAwsCredentials({ awsAccountId, awsRegion, awsRoleToAssume }: DeploymentPlatform): Promise<any>;
-}

package/bin/dist/caddy-client.d.ts

@@ -1,13 +0,0 @@
-import { DeploymentPlatform, ContainerDeploymentRequest } from 'types';
-export declare const Matchers: {
-    host: (host: any) => {
-        host: any[];
-    };
-    path: (path: any) => {
-        path: any[];
-    };
-};
-export declare class CaddyClient {
-    static deploy(deploymentPlatform: DeploymentPlatform, deploymentRequest: ContainerDeploymentRequest): Promise<void | import("node-fetch").Response>;
-    static applyDefaultServerConfig(deploymentPlatform: DeploymentPlatform): Promise<void | import("node-fetch").Response>;
-}