platformatic 1.49.1 → 1.51.8

package/cli.js

@@ -7,15 +7,12 @@ import { run as runRuntime, compile } from '@platformatic/runtime/runtime.mjs'
 import { startCommand } from '@platformatic/runtime'
 import { runService } from '@platformatic/service/service.mjs'
 import { runComposer } from '@platformatic/composer/composer.mjs'
-import { login } from '@platformatic/authenticate/authenticate.js'
 import { command as client } from '@platformatic/client-cli'
 import { readFile } from 'fs/promises'
 import { join } from 'desm'
 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'
 import {
   runControl,
@@ -61,9 +58,6 @@ program.register('help db', async (args) => runDB(['help', ...args]))
 program.register('help client', () => client([]))
 program.register('help runtime', async (args) => runRuntime(['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/help.txt

@@ -8,7 +8,6 @@ Welcome to Platformatic. Available commands are:
 * `gh` - create a new gh action for Platformatic deployments.
 * `runtime` - start Platformatic Runtime; type `platformatic runtime help` to know more.
 * `start` - start a Platformatic application.
-* `login` - generate a Platformatic login api key.
 * `client` - generate a Platformatic client.
 * `ps` - list all Platformatic runtime applications.
 * `logs` - stream logs for a Platformatic runtime application.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "platformatic",
-  "version": "1.49.1",
+  "version": "1.51.8",
   "description": "Platformatic CLI",
   "main": "cli.js",
   "type": "module",
@@ -27,7 +27,7 @@
     "mercurius"
   ],
   "devDependencies": {
-    "borp": "^0.15.0",
+    "borp": "^0.16.0",
     "c8": "^10.0.0",
     "fastify": "^4.26.2",
     "license-checker": "^25.0.1",
@@ -51,18 +51,16 @@
     "pino": "^8.19.0",
     "pino-pretty": "^11.0.0",
     "undici": "^6.9.0",
-    "@platformatic/authenticate": "1.49.1",
-    "@platformatic/client-cli": "1.49.1",
-    "@platformatic/composer": "1.49.1",
-    "@platformatic/config": "1.49.1",
-    "@platformatic/control": "1.49.1",
-    "@platformatic/db": "1.49.1",
-    "@platformatic/frontend-template": "1.49.1",
-    "@platformatic/deploy-client": "1.49.1",
-    "@platformatic/runtime": "1.49.1",
-    "@platformatic/service": "1.49.1",
-    "@platformatic/utils": "1.49.1",
-    "create-platformatic": "1.49.1"
+    "@platformatic/client-cli": "1.51.8",
+    "@platformatic/config": "1.51.8",
+    "@platformatic/composer": "1.51.8",
+    "@platformatic/control": "1.51.8",
+    "@platformatic/frontend-template": "1.51.8",
+    "@platformatic/db": "1.51.8",
+    "@platformatic/runtime": "1.51.8",
+    "@platformatic/utils": "1.51.8",
+    "create-platformatic": "1.51.8",
+    "@platformatic/service": "1.51.8"
   },
   "scripts": {
     "test": "pnpm run lint && borp --timeout 120000 --concurrency 1",

package/help/gh.txt

@@ -1,26 +0,0 @@
-Creates a gh action to deploy platformatic services on workspaces.
-
-``` bash
- $ platformatic gh -t dynamic
-```
-
-Options:
-
-* `-w  --workspace ID` - The workspace ID where the service will be deployed.
-* `-t, --type static/dynamic` - The type of the workspace. Defaults to static.
-* `-c, --config FILE` - Specify a configuration file to use.
-* `-b, --build` - Build the service before deploying (`npm run build`).
-
-If not specified, the configuration will be loaded from any of the following, in the current directory.
-
-* `platformatic.json`, or
-* `platformatic.yml`, or 
-* `platformatic.tml`, or 
-* `platformatic.json`, or
-* `platformatic.yml`, or 
-* `platformatic.tml`
-
-You can find more details about the configuration format here:
-* [Platformatic DB Configuration](https://docs.platformatic.dev/docs/db/configuration)
-* [Platformatic Service Configuration](https://docs.platformatic.dev/docs/service/configuration)
-

package/help/login.txt

@@ -1,10 +0,0 @@
-Generate a Platformatic login api key.
-
-``` bash
- $ platformatic deploy
-```
-
-Options:
-
-* `-c, --config FILE` - Specify a path to a global Platformatic config file. Defaults to `~/.platformatic/config.json`.
-* `--browser` - Automatically open default browser. If process stdout is a TTY, the default is `true`. Otherwise, the default is `false`.

package/lib/deploy.js

@@ -1,566 +0,0 @@
-'use strict'
-
-import { isAbsolute, dirname, relative, join } from 'path'
-import { readFile } from 'fs/promises'
-
-import { request } from 'undici'
-import { bold, green } from 'colorette'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import dotenv from 'dotenv'
-import inquirer from 'inquirer'
-import parseArgs from 'minimist'
-import deployClient from '@platformatic/deploy-client'
-import { getUserApiKey } from '@platformatic/authenticate'
-import errors from './errors.js'
-
-export const DEPLOY_SERVICE_HOST = 'https://deploy.platformatic.cloud'
-
-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 CREATE_NEW_WORKSPACE_CHOICE = Symbol('CREATE_NEW_WORKSPACE_CHOICE')
-const CREATE_NEW_APPLICATION_CHOICE = Symbol('CREATE_NEW_APPLICATION_CHOICE')
-
-async function askMissingWorkspaceDetails (
-  workspaceType,
-  workspaceId,
-  workspaceKey,
-  userApiKey
-) {
-  /* 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 errors.InvalidWorkspaceTypeError(workspaceType, WORKSPACE_TYPES.join(', '))
-  }
-
-  /* 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 errors.InvalidWorkspaceIdError()
-  }
-
-  /* c8 ignore next 9 */
-  if (!workspaceKey && !userApiKey) {
-    const answer = await inquirer.prompt({
-      type: 'password',
-      name: 'workspaceKey',
-      message: 'Enter workspace key:',
-      mask: '*'
-    })
-    workspaceKey = answer.workspaceKey
-  }
-
-  return {
-    workspaceType,
-    workspaceId,
-    workspaceKey
-  }
-}
-
-/* c8 ignore next 27 */
-async function askToChooseApplication (applications) {
-  const applicationChoices = applications.map((application) => {
-    return {
-      name: application.name,
-      value: application
-    }
-  })
-  applicationChoices.push({
-    name: bold('Create new application'),
-    value: CREATE_NEW_APPLICATION_CHOICE
-  })
-  applicationChoices.push({
-    name: bold('Deploy to another application'),
-    value: null
-  })
-
-  const answer = await inquirer.prompt({
-    type: 'list',
-    name: 'application',
-    message: 'Select application to deploy:',
-    choices: applicationChoices,
-    loop: false
-  })
-
-  const chosenApplication = answer.application
-  return chosenApplication
-}
-
-/* c8 ignore next 27 */
-async function askToChooseWorkspace (workspaces) {
-  const workspaceChoices = workspaces.map((workspace) => {
-    return {
-      name: `${workspace.name} (${workspace.type})`,
-      value: workspace
-    }
-  })
-  workspaceChoices.push({
-    name: bold('Create new workspace'),
-    value: CREATE_NEW_WORKSPACE_CHOICE
-  })
-  workspaceChoices.push({
-    name: bold('Deploy to another workspace'),
-    value: null
-  })
-
-  const answer = await inquirer.prompt({
-    type: 'list',
-    name: 'workspace',
-    message: 'Select workspace to deploy:',
-    choices: workspaceChoices,
-    loop: false
-  })
-
-  const chosenWorkspace = answer.workspace
-  return chosenWorkspace
-}
-
-/* c8 ignore next 14 */
-async function askToChooseOrg (orgs) {
-  const orgsChoices = orgs.map((org) => {
-    return { name: org.name, value: org.id }
-  })
-
-  const answer = await inquirer.prompt({
-    type: 'list',
-    name: 'orgId',
-    message: 'Select organisation to publish to:',
-    choices: orgsChoices
-  })
-
-  return answer.orgId
-}
-
-/* c8 ignore next 21 */
-async function askNewWorkspaceDetails () {
-  const answer = await inquirer.prompt([
-    {
-      type: 'input',
-      name: 'workspaceName',
-      message: 'Enter workspace name:'
-    },
-    {
-      type: 'list',
-      name: 'workspaceType',
-      message: 'Select workspace type:',
-      choices: WORKSPACE_TYPES
-    }
-  ])
-
-  return {
-    workspaceName: answer.workspaceName,
-    workspaceType: answer.workspaceType
-  }
-}
-
-/* c8 ignore next 12 */
-async function askNewApplicationDetails () {
-  const answer = await inquirer.prompt({
-    type: 'input',
-    name: 'applicationName',
-    message: 'Enter application name:'
-  })
-
-  return {
-    applicationName: answer.applicationName
-  }
-}
-
-/* c8 ignore next 19 */
-async function askToChooseDeployLabel (labels) {
-  const entryPointChoices = labels.map((label) => {
-    return { name: label, value: label }
-  })
-  entryPointChoices.push({
-    name: 'Deploy to another label',
-    value: null
-  })
-
-  const answer = await inquirer.prompt({
-    type: 'list',
-    name: 'entryPoint',
-    message: 'Select entry point to deploy:',
-    choices: entryPointChoices
-  })
-
-  return answer.entryPoint
-}
-
-/* c8 ignore next 10 */
-async function askToEnterDeployLabel () {
-  const answer = await inquirer.prompt({
-    type: 'input',
-    name: 'label',
-    message: 'Enter deploy label:',
-    default: 'cli:deploy-1'
-  })
-  return answer.label
-}
-
-async function readWorkspaceDetails (workspaceKeysPath) {
-  /* c8 ignore next 3 */
-  if (!isAbsolute(workspaceKeysPath)) {
-    workspaceKeysPath = join(process.cwd(), workspaceKeysPath)
-  }
-
-  const workspaceFile = await readFile(workspaceKeysPath, 'utf8')
-  const workspaceEnvVars = dotenv.parse(workspaceFile)
-
-  if (
-    workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_ID &&
-    workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY
-  ) {
-    return {
-      workspaceType: 'dynamic',
-      workspaceId: workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_ID,
-      workspaceKey: workspaceEnvVars.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY
-    }
-  }
-
-  if (
-    workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_ID &&
-    workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_API_KEY
-  ) {
-    return {
-      workspaceType: 'static',
-      workspaceId: workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_ID,
-      workspaceKey: workspaceEnvVars.PLATFORMATIC_STATIC_WORKSPACE_API_KEY
-    }
-  }
-
-  throw new errors.CouldNotFindWorkspaceKeysError()
-}
-
-/* c8 ignore next 18 */
-async function getUserApplications (deployServiceHost, userApiKey) {
-  const { statusCode, body } = await request(`${deployServiceHost}/applications`, {
-    headers: {
-      'Content-Type': 'application/json',
-      'x-platformatic-user-api-key': userApiKey
-    }
-  })
-
-  if (statusCode !== 200) {
-    const error = await body.text()
-    console.error(error)
-    throw new errors.CouldNotFetchUserApplicationsError()
-  }
-
-  const { applications } = await body.json()
-  return applications
-}
-
-/* c8 ignore next 18 */
-async function getUserOrgs (deployServiceHost, userApiKey) {
-  const url = deployServiceHost + '/organisations'
-  const { statusCode, body } = await request(url, {
-    method: 'GET',
-    headers: {
-      'content-type': 'application/json',
-      'x-platformatic-user-api-key': userApiKey
-    }
-  })
-
-  if (statusCode !== 200) {
-    throw new errors.CouldNotFetchUserOrgsError()
-  }
-
-  const { orgs } = await body.json()
-  return orgs
-}
-
-/* c8 ignore next 18 */
-async function getWorkspaceLabels (deployServiceHost, workspaceId, userApiKey) {
-  const { statusCode, body } = await request(`${deployServiceHost}/entrypoints`, {
-    headers: {
-      'Content-Type': 'application/json',
-      'x-platformatic-workspace-id': workspaceId,
-      'x-platformatic-user-api-key': userApiKey
-    }
-  })
-
-  if (statusCode !== 200) {
-    const error = await body.text()
-    console.error(error)
-    throw new errors.CouldNotFetchDeployLabelsError()
-  }
-
-  const { entryPoints } = await body.json()
-  return entryPoints.map((entryPoint) => entryPoint.label)
-}
-
-/* c8 ignore next 30 */
-async function createWorkspace (
-  deployServiceHost,
-  userApiKey,
-  appId,
-  workspaceName,
-  workspaceType
-) {
-  const { statusCode, body } = await request(`${deployServiceHost}/workspaces`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-platformatic-user-api-key': userApiKey
-    },
-    body: JSON.stringify({
-      appId,
-      name: workspaceName,
-      type: workspaceType
-    })
-  })
-
-  if (statusCode !== 200) {
-    const error = await body.text()
-    console.error(error)
-    throw new errors.CouldNotCreateWorkspaceError()
-  }
-
-  const { id: workspaceId } = await body.json()
-  return workspaceId
-}
-
-/* c8 ignore next 25 */
-async function createApplication (
-  deployServiceHost,
-  userApiKey,
-  orgId,
-  applicationName
-) {
-  const { statusCode, body } = await request(`${deployServiceHost}/applications`, {
-    method: 'POST',
-    headers: {
-      'Content-Type': 'application/json',
-      'x-platformatic-user-api-key': userApiKey
-    },
-    body: JSON.stringify({ orgId, name: applicationName })
-  })
-
-  if (statusCode !== 200) {
-    const error = await body.text()
-    console.error(error)
-    throw new errors.CouldNotCreateApplicationError()
-  }
-
-  const { id: applicationId } = await body.json()
-  return applicationId
-}
-
-/* c8 ignore next 16 */
-async function getUserOrgDetails (deployServiceHost, userApiKey) {
-  const userOrgs = await getUserOrgs(deployServiceHost, userApiKey)
-  if (userOrgs.length === 0) {
-    throw new errors.NoUserOrgsError()
-  }
-
-  let orgId = null
-  if (userOrgs.length === 1) {
-    orgId = userOrgs[0].id
-  } else {
-    orgId = await askToChooseOrg(userOrgs)
-  }
-
-  return { id: orgId }
-}
-
-/* c8 ignore next 26 */
-async function getUserApplicationDetails (deployServiceHost, userApiKey) {
-  const applications = await getUserApplications(deployServiceHost, userApiKey)
-  if (applications.length === 0) return null
-
-  const application = await askToChooseApplication(applications)
-  if (application === null) return null
-
-  if (application === CREATE_NEW_APPLICATION_CHOICE) {
-    const { id: orgId } = await getUserOrgDetails(deployServiceHost, userApiKey)
-    const { applicationName } = await askNewApplicationDetails()
-    const applicationId = await createApplication(
-      deployServiceHost,
-      userApiKey,
-      orgId,
-      applicationName
-    )
-    return { id: applicationId, name: applicationName, workspaces: [] }
-  }
-  return {
-    id: application.id,
-    name: application.name,
-    workspaces: application.workspaces
-  }
-}
-
-/* c8 ignore next 24 */
-async function getUserWorkspaceDetails (deployServiceHost, userApiKey) {
-  const application = await getUserApplicationDetails(deployServiceHost, userApiKey)
-  if (application === null) return null
-
-  const workspaceDetails = await askToChooseWorkspace(application.workspaces)
-  if (workspaceDetails === null) return null
-
-  if (workspaceDetails === CREATE_NEW_WORKSPACE_CHOICE) {
-    const { workspaceName, workspaceType } = await askNewWorkspaceDetails()
-    const workspaceId = await createWorkspace(
-      deployServiceHost,
-      userApiKey,
-      application.id,
-      workspaceName,
-      workspaceType
-    )
-    return { workspaceId, workspaceType }
-  }
-
-  return {
-    workspaceId: workspaceDetails.id,
-    workspaceType: workspaceDetails.type
-  }
-}
-
-export async function deploy (argv) {
-  const logger = pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid'
-  }))
-
-  logger.info('This application will be deployed to ' + bold(green('Platformatic Cloud')) + '. To change the target use the --deploy-service-host flag')
-
-  try {
-    const args = parseArgs(argv, {
-      alias: {
-        config: 'c',
-        keys: 'k',
-        type: 't',
-        label: 'l',
-        env: 'e',
-        secrets: 's',
-        compileTypescript: ['compile', 'C']
-      },
-      boolean: ['compileTypescript'],
-      string: [
-        'type',
-        'label',
-        'workspace-id',
-        'workspace-key',
-        'env',
-        'secrets',
-        'deploy-service-host'
-      ],
-      default: {
-        'deploy-service-host': DEPLOY_SERVICE_HOST,
-        compileTypescript: true
-      }
-    })
-
-    const deployServiceHost = args['deploy-service-host']
-
-    let workspaceId = args['workspace-id']
-    let workspaceType = args.type
-
-    let workspaceKey = args['workspace-key']
-    let userApiKey = null
-
-    if (!workspaceId) {
-      if (args.keys) {
-        const workspaceDetails = await readWorkspaceDetails(args.keys)
-        workspaceId = workspaceDetails.workspaceId
-        workspaceType = workspaceDetails.workspaceType
-        workspaceKey = workspaceDetails.workspaceKey
-      /* c8 ignore next 10 */
-      } else {
-        userApiKey = await getUserApiKey().catch(() => {})
-        if (userApiKey) {
-          const workspaceDetails = await getUserWorkspaceDetails(deployServiceHost, userApiKey)
-          if (workspaceDetails) {
-            workspaceId = workspaceDetails.workspaceId
-            workspaceType = workspaceDetails.workspaceType
-          }
-        }
-      }
-    }
-
-    const workspaceDetails = await askMissingWorkspaceDetails(
-      workspaceType,
-      workspaceId,
-      workspaceKey,
-      userApiKey
-    )
-    workspaceId = workspaceDetails.workspaceId
-    workspaceType = workspaceDetails.workspaceType
-    workspaceKey = workspaceDetails.workspaceKey
-
-    let label = args.label
-
-    if (workspaceType === 'dynamic') {
-      /* c8 ignore next 17 */
-      if (!label) {
-        userApiKey = userApiKey || await getUserApiKey().catch(() => {})
-
-        if (userApiKey) {
-          const workspaceLabels = await getWorkspaceLabels(
-            deployServiceHost,
-            workspaceId,
-            userApiKey
-          )
-          if (workspaceLabels.length !== 0) {
-            label = await askToChooseDeployLabel(workspaceLabels)
-          }
-        }
-        if (!label) {
-          label = await askToEnterDeployLabel()
-        }
-      }
-
-      const labelPrefix = label.split(':')[0]
-      const labelPrefixes = ['cli', 'github-pr']
-      if (!labelPrefix || !labelPrefixes.includes(labelPrefix)) {
-        label = `cli:${label}`
-      }
-    }
-
-    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'
-
-    await deployClient.deploy({
-      deployServiceHost,
-      workspaceId,
-      workspaceKey,
-      userApiKey,
-      pathToProject,
-      pathToConfig,
-      pathToEnvFile,
-      pathToSecretsFile,
-      secrets: {},
-      variables: {},
-      label,
-      logger
-    })
-  } catch (err) {
-    logger.error(err.message)
-    process.exit(1)
-  }
-}

package/lib/gh.js

@@ -1,81 +0,0 @@
-import {
-  createStaticWorkspaceGHAction,
-  createDynamicWorkspaceGHAction
-} from 'create-platformatic'
-
-import parseArgs from 'minimist'
-import { access } from 'fs/promises'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import ConfigManager from '@platformatic/config'
-
-export const createGHAction = async (logger, env, config, buildTS, type, projectDir = process.cwd()) => {
-  if (type === 'static') {
-    await createStaticWorkspaceGHAction(logger, env, config, projectDir, buildTS)
-    return
-  }
-  await createDynamicWorkspaceGHAction(logger, env, config, projectDir, buildTS)
-}
-
-const logger = pino(pretty({
-  translateTime: 'SYS:HH:MM:ss',
-  ignore: 'hostname,pid'
-}))
-
-const configFileNames = ConfigManager.listConfigFiles()
-
-async function isFileAccessible (filename) {
-  try {
-    await access(filename)
-    return true
-  } catch (err) {
-    return false
-  }
-}
-
-export const gh = async (argv) => {
-  const args = parseArgs(argv, {
-    default: {
-      type: 'static',
-      build: false
-    },
-    alias: {
-      config: 'c',
-      type: 't',
-      help: 'h',
-      build: 'b'
-    },
-    boolean: ['build']
-  })
-
-  if (!['static', 'dynamic'].includes(args.type)) {
-    logger.error(`Invalid type: [${args.type}]. Type must be either static or dynamic`)
-    process.exit(1)
-  }
-
-  let configFilename = args.config
-  if (!configFilename) {
-    const configFilesAccessibility = await Promise.all(configFileNames.map((fileName) => isFileAccessible(fileName)))
-    configFilename = configFileNames.find((value, index) => configFilesAccessibility[index])
-  }
-
-  if (!configFilename) {
-    logger.error('No config file found')
-    process.exit(1)
-  }
-
-  if (await isFileAccessible('.env')) {
-    // We cannot add this automatically, because there might be credentials .env file
-    logger.info('Found .env file. If you need these variables in your GitHub Action, please add them to env: in "Deploy Project" step')
-  }
-
-  const env = {
-    plt_custom_variable: 'change-me',
-    custom_variable1: 'change-me'
-  }
-  await createGHAction(logger, env, configFilename, args.build, args.type)
-
-  const workspaceName = args.type === 'static' ? 'PLATFORMATIC_STATIC_WORKSPACE_ID ' : 'PLATFORMATIC_DYNAMIC_WORKSPACE_ID'
-  const secretName = args.type === 'static' ? 'PLATFORMATIC_STATIC_WORKSPACE_API_KEY' : 'PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY'
-  logger.info(`Github action successfully created please add ${workspaceName} and ${secretName} as repository secrets.`)
-}