platformatic 0.20.1 → 0.21.0

package/cli.js

@@ -12,6 +12,7 @@ import { isColorSupported } from 'colorette'
 import helpMe from 'help-me'
 import { upgrade } from './lib/upgrade.js'
 import { gh } from './lib/gh.js'
+import { deploy } from './lib/deploy.js'
 
 import { logo } from './lib/ascii.js'
 
@@ -44,6 +45,7 @@ program.register('help db', async (args) => runDB(['help', ...args]))
 program.register('help service', async (args) => runService(['help', ...args]))
 program.register({ command: 'login', strict: true }, login)
 program.register('gh', gh)
+program.register('deploy', deploy)
 
 const args = minimist(process.argv.slice(2), {
   boolean: ['help', 'version'],

package/help/deploy.txt

@@ -0,0 +1,22 @@
+Deploys a Platformatic application to the cloud
+
+``` bash
+ $ platformatic deploy
+```
+
+Options:
+
+  -t, --type      static/dynamic  The type of the workspace.
+  -c, --config    FILE            Specify a configuration file to use
+  -l  --label     TEXT            The deploy label. Only for dynamic workspaces.
+  -e  --env       FILE            The environment file to use. Default: ".env"
+  -s  --secrets   FILE            The secrets file to use. Default: ".secrets.env"
+  --workspace-id  uuid            The workspace id where the application will be deployed
+  --workspace-key TEXT            The workspace key where the application will be deployed
+
+To deploy a Platformatic application to the cloud you should go to the 
+Platformatic cloud dashboard and create a workspace. Then you can get your
+workspace id and key from the workspace settings page.
+
+Tp deploy an application to a dynamic workspace, you will need to specify the
+deploy label. You can get it in you cloud dashboard or specify a new one.

package/help/help.txt

@@ -6,3 +6,4 @@ Welcome to Platformatic. Available commands are:
 * service - start Platformatic Service; type `platformatic service help` to know more.
 * upgrade - upgrade the Platformatic configuration to the latest version.
 * gh - creates a new gh action for Platformatic deployments
+* deploy - deploy a Platformatic application to the cloud

package/lib/deploy.js

@@ -0,0 +1,143 @@
+'use strict'
+
+import { isAbsolute, dirname, relative } from 'path'
+
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import inquirer from 'inquirer'
+import parseArgs from 'minimist'
+import deployClient from '@platformatic/deploy-client'
+
+export const DEPLOY_SERVICE_HOST = 'https://plt-production-deploy-service.fly.dev'
+
+const WORKSPACE_TYPES = ['static', 'dynamic']
+const UUID_REGEX = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i
+
+const logger = pino(pretty({
+  translateTime: 'SYS:HH:MM:ss',
+  ignore: 'hostname,pid'
+}))
+
+export async function deploy (argv) {
+  try {
+    const args = parseArgs(argv, {
+      alias: {
+        config: 'c',
+        type: 't',
+        label: 'l',
+        env: 'e',
+        secrets: 's'
+      },
+      string: [
+        'type',
+        'label',
+        'workspace-id',
+        'workspace-key',
+        'env',
+        'secrets',
+        'deploy-service-host'
+      ],
+      default: {
+        'deploy-service-host': DEPLOY_SERVICE_HOST
+      }
+    })
+
+    let workspaceType = args.type
+    /* c8 ignore next 9 */
+    if (!workspaceType) {
+      const answer = await inquirer.prompt({
+        type: 'list',
+        name: 'workspaceType',
+        message: 'Select workspace type:',
+        choices: WORKSPACE_TYPES
+      })
+      workspaceType = answer.workspaceType
+    }
+
+    if (!WORKSPACE_TYPES.includes(workspaceType)) {
+      throw new Error(
+        `Invalid workspace type provided: "${workspaceType}". ` +
+        `Type must be one of: ${WORKSPACE_TYPES.join(', ')}.`
+      )
+    }
+
+    let workspaceId = args['workspace-id']
+    /* c8 ignore next 8 */
+    if (!workspaceId) {
+      const answer = await inquirer.prompt({
+        type: 'input',
+        name: 'workspaceId',
+        message: 'Enter workspace id:'
+      })
+      workspaceId = answer.workspaceId
+    }
+
+    if (!UUID_REGEX.test(workspaceId)) {
+      throw new Error('Invalid workspace id provided. Workspace id must be a valid uuid.')
+    }
+
+    let workspaceKey = args['workspace-key']
+    /* c8 ignore next 9 */
+    if (!workspaceKey) {
+      const answer = await inquirer.prompt({
+        type: 'password',
+        name: 'workspaceKey',
+        message: 'Enter workspace key:',
+        mask: '*'
+      })
+      workspaceKey = answer.workspaceKey
+    }
+
+    let label = args.label
+    if (workspaceType === 'dynamic') {
+    /* c8 ignore next 9 */
+      if (!label) {
+        const answer = await inquirer.prompt({
+          type: 'input',
+          name: 'label',
+          message: 'Enter deploy label:',
+          default: 'cli:deploy-1'
+        })
+        label = answer.label
+      }
+
+      const labelPrefix = label.split(':')[0]
+      const labelPrefixes = ['cli', 'github-pr']
+      if (!labelPrefix || !labelPrefixes.includes(labelPrefix)) {
+        throw new Error(
+          `Invalid deploy label provided: "${label}". ` +
+          `Label must be prefixed with one of: ${labelPrefixes.join(', ')}.`
+        )
+      }
+    }
+
+    let pathToConfig = args.config
+    let pathToProject = process.cwd()
+
+    if (pathToConfig && isAbsolute(pathToConfig)) {
+      pathToProject = dirname(pathToConfig)
+      pathToConfig = relative(pathToProject, pathToConfig)
+    }
+
+    const pathToEnvFile = args.env || '.env'
+    const pathToSecretsFile = args.secrets || '.secrets.env'
+    const deployServiceHost = args['deploy-service-host']
+
+    await deployClient.deploy({
+      deployServiceHost,
+      workspaceId,
+      workspaceKey,
+      pathToProject,
+      pathToConfig,
+      pathToEnvFile,
+      pathToSecretsFile,
+      secrets: {},
+      variables: {},
+      label,
+      logger
+    })
+  } catch (err) {
+    logger.error(err.message)
+    process.exit(1)
+  }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "platformatic",
-  "version": "0.20.1",
+  "version": "0.21.0",
   "description": "Platformatic CLI",
   "main": "cli.js",
   "type": "module",
@@ -35,9 +35,11 @@
     "split2": "^4.1.0",
     "standard": "^17.0.0",
     "tap": "^16.3.4",
-    "undici": "^5.20.0"
+    "undici": "^5.20.0",
+    "fastify": "^4.13.0"
   },
   "dependencies": {
+    "@platformatic/deploy-client": "^0.1.1",
     "colorette": "^2.0.19",
     "commist": "^3.2.0",
     "desm": "^1.3.0",
@@ -45,12 +47,13 @@
     "minimist": "^1.2.8",
     "pino": "^8.11.0",
     "pino-pretty": "^10.0.0",
-    "@platformatic/authenticate": "0.20.1",
-    "@platformatic/db": "0.20.1",
-    "@platformatic/metaconfig": "0.20.1",
-    "@platformatic/service": "0.20.1",
-    "@platformatic/client-cli": "0.20.1",
-    "create-platformatic": "0.20.1"
+    "inquirer": "^9.1.4",
+    "@platformatic/authenticate": "0.21.0",
+    "@platformatic/db": "0.21.0",
+    "@platformatic/metaconfig": "0.21.0",
+    "@platformatic/service": "0.21.0",
+    "@platformatic/client-cli": "0.21.0",
+    "create-platformatic": "0.21.0"
   },
   "scripts": {
     "test": "standard | snazzy && c8 --100 tap --no-coverage test/*.test.js",

package/test/deploy.test.js

@@ -0,0 +1,174 @@
+import { test } from 'tap'
+import { join } from 'desm'
+import { execa } from 'execa'
+
+import { cliPath, startDeployService, startMachine } from './helper.js'
+
+test('should deploy to a static workspace to the cloud', async (t) => {
+  const workspaceType = 'static'
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+
+  const machineHost = await startMachine(t)
+  const deployServiceHost = await startDeployService(t, {
+    createBundleCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.match(request.body, {
+        bundle: {
+          appType: 'db',
+          configPath: 'platformatic.db.json'
+        }
+      })
+      t.ok(request.body.bundle.checksum)
+    },
+    createDeploymentCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.same(
+        request.body,
+        {
+          variables: {
+            PLT_ENV_VARIABLE1: 'platformatic_variable1',
+            PLT_ENV_VARIABLE2: 'platformatic_variable2'
+          },
+          secrets: {
+            PLT_SECRET_1: 'platformatic_secret_1',
+            PLT_SECRET_2: 'platformatic_secret_2'
+          }
+        }
+      )
+      reply.code(200).send({ entryPointUrl: machineHost })
+    }
+  })
+
+  await execa('node', [
+    cliPath, 'deploy',
+    '--type', workspaceType,
+    '--config', pathToConfig,
+    '--workspace-id', workspaceId,
+    '--workspace-key', workspaceKey,
+    '--deploy-service-host', deployServiceHost
+  ])
+})
+
+test('should deploy to a dynamic workspace to the cloud', async (t) => {
+  const workspaceType = 'dynamic'
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const label = 'cli:deploy-2'
+
+  const machineHost = await startMachine(t)
+  const deployServiceHost = await startDeployService(t, {
+    createBundleCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.match(request.body, {
+        bundle: {
+          appType: 'db',
+          configPath: 'platformatic.db.json'
+        }
+      })
+      t.ok(request.body.bundle.checksum)
+    },
+    createDeploymentCallback: (request, reply) => {
+      t.equal(request.headers['x-platformatic-workspace-id'], workspaceId)
+      t.equal(request.headers['x-platformatic-api-key'], workspaceKey)
+      t.same(
+        request.body,
+        {
+          label,
+          variables: {
+            PLT_ENV_VARIABLE1: 'platformatic_variable1',
+            PLT_ENV_VARIABLE2: 'platformatic_variable2'
+          },
+          secrets: {
+            PLT_SECRET_1: 'platformatic_secret_1',
+            PLT_SECRET_2: 'platformatic_secret_2'
+          }
+        }
+      )
+      reply.code(200).send({ entryPointUrl: machineHost })
+    }
+  })
+
+  await execa('node', [
+    cliPath, 'deploy',
+    '--type', workspaceType,
+    '--label', label,
+    '--config', pathToConfig,
+    '--workspace-id', workspaceId,
+    '--workspace-key', workspaceKey,
+    '--deploy-service-host', deployServiceHost
+  ])
+})
+
+test('should fail if workspace id is not a uuid', async (t) => {
+  const workspaceType = 'static'
+  const workspaceId = 'not-a-uuid'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+
+  try {
+    await execa('node', [
+      cliPath, 'deploy',
+      '--type', workspaceType,
+      '--config', pathToConfig,
+      '--workspace-id', workspaceId,
+      '--workspace-key', workspaceKey,
+      '--deploy-service-host', 'http://localhost:5555'
+    ])
+    t.fail('should have failed')
+  } catch (err) {
+    t.ok(err.message.includes('Invalid workspace id provided. Workspace id must be a valid uuid.'))
+  }
+})
+
+test('should fail if invalid workspace type provided', async (t) => {
+  const workspaceType = 'wrong'
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+
+  try {
+    await execa('node', [
+      cliPath, 'deploy',
+      '--type', workspaceType,
+      '--config', pathToConfig,
+      '--workspace-id', workspaceId,
+      '--workspace-key', workspaceKey,
+      '--deploy-service-host', 'http://localhost:5555'
+    ])
+    t.fail('should have failed')
+  } catch (err) {
+    t.ok(err.message.includes('Invalid workspace type provided'))
+  }
+})
+
+test('should fail if deploy label does not start with a "cli:" prefix', async (t) => {
+  const workspaceType = 'dynamic'
+  const workspaceId = 'b3d7f7e0-8c03-11e8-9eb6-529269fb1459'
+  const workspaceKey = 'b3d7f7e08c0311e89eb6529269fb1459'
+  const pathToConfig = join(import.meta.url, './fixtures/app-to-deploy/platformatic.db.json')
+  const label = 'my label'
+
+  try {
+    await execa('node', [
+      cliPath, 'deploy',
+      '--type', workspaceType,
+      '--label', label,
+      '--config', pathToConfig,
+      '--workspace-id', workspaceId,
+      '--workspace-key', workspaceKey,
+      '--deploy-service-host', 'http://localhost:5555'
+    ])
+    t.fail('should have failed')
+  } catch (err) {
+    t.ok(err.message.includes(
+      `Invalid deploy label provided: "${label}". ` +
+      'Label must be prefixed with one of: cli, github-pr.'
+    ))
+  }
+})

package/test/fixtures/app-to-deploy/.env

@@ -0,0 +1,2 @@
+PLT_ENV_VARIABLE1=platformatic_variable1
+PLT_ENV_VARIABLE2=platformatic_variable2

package/test/fixtures/app-to-deploy/.secrets.env

@@ -0,0 +1,2 @@
+PLT_SECRET_1=platformatic_secret_1
+PLT_SECRET_2=platformatic_secret_2

package/test/fixtures/app-to-deploy/package.json

@@ -0,0 +1,7 @@
+{
+  "devDependencies": {
+    "@platformatic/sql-graphql": "^0.9.2",
+    "@platformatic/sql-mapper": "^0.9.2",
+    "platformatic": "^0.11.0"
+  }
+}

package/test/fixtures/app-to-deploy/platformatic.db.json

@@ -0,0 +1,17 @@
+{
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 3042
+  },
+  "core": {
+    "connectionString": "sqlite://db.sqlite",
+    "graphql": true,
+    "ignore": {
+      "versions": true
+    }
+  },
+  "migrations": {
+    "dir": "migrations",
+    "table": "versions"
+  }
+}

package/test/helper.js

@@ -1,7 +1,61 @@
 import { join } from 'desm'
+import fastify from 'fastify'
 
 const cliPath = join(import.meta.url, '..', 'cli.js')
 
+async function startDeployService (t, options = {}) {
+  const deployService = fastify({ keepAliveTimeout: 1 })
+
+  deployService.post('/bundles', async (request, reply) => {
+    const createBundleCallback = options.createBundleCallback || (() => {})
+    await createBundleCallback(request, reply)
+
+    return {
+      id: 'default-bundle-id',
+      token: 'default-upload-token',
+      isBundleUploaded: false
+    }
+  })
+
+  deployService.post('/deployments', async (request, reply) => {
+    const createDeploymentCallback = options.createDeploymentCallback || (() => {})
+    await createDeploymentCallback(request, reply)
+  })
+
+  deployService.addContentTypeParser(
+    'application/x-tar',
+    { bodyLimit: 1024 * 1024 * 1024 },
+    (request, payload, done) => done()
+  )
+
+  deployService.put('/upload', async (request, reply) => {
+    const uploadCallback = options.uploadCallback || (() => {})
+    await uploadCallback(request, reply)
+  })
+
+  t.teardown(async () => {
+    await deployService.close()
+  })
+
+  return deployService.listen({ port: 3042 })
+}
+
+async function startMachine (t, callback = () => {}) {
+  const machine = fastify({ keepAliveTimeout: 1 })
+
+  machine.get('/', async (request, reply) => {
+    await callback(request, reply)
+  })
+
+  t.teardown(async () => {
+    await machine.close()
+  })
+
+  return machine.listen({ port: 0 })
+}
+
 export {
-  cliPath
+  cliPath,
+  startDeployService,
+  startMachine
 }