platformatic 2.0.0-alpha.2 → 2.0.0-alpha.21

package/cli.js

@@ -1,25 +1,27 @@
 #! /usr/bin/env node
 
-import { createRequire } from 'node:module'
-import path from 'node:path'
-import { pathToFileURL } from 'node:url'
-import { readFile } from 'node:fs/promises'
-import commist from 'commist'
-import minimist from 'minimist'
-import { run as runRuntime, compile } from '@platformatic/runtime/runtime.mjs'
-import { startCommand } from '@platformatic/runtime'
 import { command as client } from '@platformatic/client-cli'
-import { join } from 'desm'
-import { isColorSupported } from 'colorette'
-import helpMe from 'help-me'
-import { upgrade } from './lib/upgrade.js'
-import { logo } from './lib/ascii.js'
 import {
-  runControl,
   getRuntimesCommand,
   injectRuntimeCommand,
+  runControl,
   streamRuntimeLogsCommand
 } from '@platformatic/control/control.js'
+import { startCommand } from '@platformatic/runtime'
+import { compile, run as runRuntime } from '@platformatic/runtime/runtime.mjs'
+import { isColorSupported } from 'colorette'
+import commist from 'commist'
+import { join } from 'desm'
+import helpMe from 'help-me'
+import minimist from 'minimist'
+import { readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import path from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { logo } from './lib/ascii.js'
+import { build } from './lib/build.js'
+import { resolve } from './lib/resolve.js'
+import { upgrade } from './lib/upgrade.js'
 
 const program = commist({ maxDistance: 2 })
 const help = helpMe({
@@ -47,35 +49,37 @@ const ensureCommand = async ({ output, help }) => {
   process.exit(1)
 }
 
-program.register('db', async (args) => {
+program.register('db', async args => {
   const { runDB } = await load('@platformatic/db/db.mjs')
   return ensureCommand(await runDB(args))
 })
-program.register('runtime', async (args) => ensureCommand(await runRuntime(args)))
-program.register('service', async (args) => {
+program.register('runtime', async args => ensureCommand(await runRuntime(args)))
+program.register('service', async args => {
   const { runService } = await load('@platformatic/service/service.mjs')
   return ensureCommand(await runService(args))
 })
-program.register('composer', async (args) => {
+program.register('composer', async args => {
   const { runComposer } = await load('@platformatic/composer/composer.mjs')
   return ensureCommand(await runComposer(args))
 })
-program.register('start', async (args) => ensureCommand(await startCommand(args)))
-program.register('ctl', async (args) => ensureCommand(await runControl(args)))
-program.register('ps', async (args) => getRuntimesCommand(args))
-program.register('inject', async (args) => injectRuntimeCommand(args))
-program.register('logs', async (args) => streamRuntimeLogsCommand(args))
+program.register('start', async args => ensureCommand(await startCommand(args)))
+program.register('ctl', async args => ensureCommand(await runControl(args)))
+program.register('ps', async args => getRuntimesCommand(args))
+program.register('inject', async args => injectRuntimeCommand(args))
+program.register('logs', async args => streamRuntimeLogsCommand(args))
 program.register('upgrade', upgrade)
+program.register('resolve', resolve)
 program.register('client', client)
-program.register('compile', async (args) => await compile(args) ? null : process.exit(1))
+program.register('build', build)
+program.register('compile', async args => ((await compile(args)) ? null : process.exit(1)))
 program.register('help', help.toStdout)
-program.register('help db', async (args) => {
+program.register('help db', async args => {
   const { runDB } = await load('@platformatic/db/db.mjs')
   return runDB(['help', ...args])
 })
 program.register('help client', () => client([]))
-program.register('help runtime', async (args) => runRuntime(['help', ...args]))
-program.register('help service', async (args) => {
+program.register('help runtime', async args => runRuntime(['help', ...args]))
+program.register('help service', async args => {
   const { runService } = await load('@platformatic/service/service.mjs')
   return runService(['help', ...args])
 })
@@ -89,7 +93,7 @@ const args = minimist(process.argv.slice(2), {
 })
 
 if (args.version && !args._.includes('inject')) {
-  const version = JSON.parse(await readFile(join(import.meta.url, 'package.json'))).version
+  const version = JSON.parse(await readFile(join(import.meta.url, 'package.json'), 'utf-8')).version
   console.log('v' + version)
   process.exit(0)
 }
@@ -99,7 +103,7 @@ if (args.help) {
 } else if (process.argv.length > 2) {
   const output = await program.parseAsync(process.argv.slice(2))
   await ensureCommand({ output, help })
-/* c8 ignore start */
+  /* c8 ignore start */
 } else {
   if (isColorSupported && process.stdout.isTTY) {
     console.log(logo)

package/eslint.config.js

@@ -0,0 +1,3 @@
+import neostandard from 'neostandard'
+
+export default neostandard({ ignores: ['**/.astro', '**/.next', '**/.vite', '**/dist'] })

package/help/help.txt

@@ -1,15 +1,18 @@
 Welcome to Platformatic. Available commands are:
 
-* `help` - display this message.
-* `help <command>` - show more information about a command.
 * `db` - start Platformatic DB; type `platformatic db help` to know more.
-* `service` - start Platformatic Service; type `platformatic service help` to know more.
-* `upgrade` - upgrade the Platformatic configuration to the latest version.
-* `gh` - create a new gh action for Platformatic deployments.
 * `runtime` - start Platformatic Runtime; type `platformatic runtime help` to know more.
+* `service` - start Platformatic Service; type `platformatic service help` to know more.
+* `composer` - start Platformatic Composer; type `platformatic composer help` to know more.
 * `start` - start a Platformatic application.
-* `client` - generate a Platformatic client.
+* `ctl` - Platformatic Control commands; `platformatic ctl help` to know more.
 * `ps` - list all Platformatic runtime applications.
-* `logs` - stream logs for a Platformatic runtime application.
 * `inject` - inject a request into a Platformatic runtime application.
-* `ctl` - Platformatic Control commands; `platformatic ctl help` to know more.
+* `logs` - stream logs for a Platformatic runtime application.
+* `upgrade` - upgrade the Platformatic configuration to the latest version.
+* `resolve` - resolve Platformatic Runtime external services
+* `client` - generate a Platformatic client.
+* `build` - builds all services.
+* `compile` - compile all typescript plugins.
+* `help` - display this message.
+* `help <command>` - show more information about a command.

package/help/resolve.txt

@@ -0,0 +1,57 @@
+Resolve Platformatic Runtime external services
+
+``` bash
+ $ platformatic resolve
+```
+
+Options:
+
+* `-c, --config FILE` - Path to the runtime configuration file.
+* `-u, --username string` - Username for the service repository.
+* `-p, --password string` - Password for the service repository.
+
+Platformatic resolve command resolves runtime services that have the `url` in their configuration.
+By default services are cloned with `git` to the `external` directory inside the runtime directory.
+To change the directory where a service is cloned, you can set the `path` property in the service configuration.
+
+After cloning the service, the resolve command will set the relative path to the service in the runtime configuration file.
+
+Example of the runtime platformatic.json configuration file:
+
+```json
+{
+  "$schema": "https://schemas.platformatic.dev/@platformatic/runtime/2.0.0.json",
+  "entrypoint": "service-1",
+  "services": [
+    {
+      "id": "service-1",
+      "path": "./services/service-1",
+      "config": "platformatic.json"
+    },
+    {
+      "id": "service-2",
+      "config": "platformatic.json",
+      "url": "https://github.com/test-owner/test-service.git"
+    },
+    {
+      "id": "service-3",
+      "config": "platformatic.json",
+      "path": "./custom-external/service-3",
+      "url": "https://github.com/test-owner/test-service.git"
+    }
+  ],
+}
+```
+
+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/lib/build.js

@@ -0,0 +1,37 @@
+import { Store, loadConfig as pltConfigLoadConfig } from '@platformatic/config'
+import { buildRuntime, platformaticRuntime } from '@platformatic/runtime'
+import { ensureLoggableError } from '@platformatic/utils'
+
+export async function build (args) {
+  const store = new Store()
+  store.add(platformaticRuntime)
+
+  const config = await pltConfigLoadConfig({}, args, store)
+  config.configManager.args = config.args
+
+  const runtimeConfig = config.configManager
+  const runtime = await buildRuntime(runtimeConfig)
+  const logger = runtime.logger
+
+  // Gather informations for all services before starting
+  const { services } = await runtime.getServices()
+
+  for (const { id } of services) {
+    logger.info(`Building service ${id}" ...`)
+
+    try {
+      await runtime.buildService(id)
+    } catch (error) {
+      if (error.code === 'PLT_BASIC_NON_ZERO_EXIT_CODE') {
+        logger.error(`Building service "${id}" has failed with exit code ${error.exitCode}.`)
+      } else {
+        logger.error({ err: ensureLoggableError(error) }, `Building service "${id}" has throw an exception.`)
+      }
+
+      process.exit(1)
+    }
+  }
+
+  logger.info('✅ All services have been built.')
+  await runtime.close(false, true)
+}

package/lib/errors.js

@@ -13,7 +13,7 @@ const errors = {
   CouldNotCreateWorkspaceError: createError(`${ERROR_PREFIX}_COULD_NOT_CREATE_WORKSPACE`, 'Could not create workspace'),
   CouldNotCreateApplicationError: createError(`${ERROR_PREFIX}_COULD_NOT_CREATE_APPLICATION`, 'Could not create application'),
   CouldNotFetchUserOrgsError: createError(`${ERROR_PREFIX}_COULD_NOT_FETCH_USER_ORGS`, 'Could not fetch user ogranisations'),
-  NoUserOrgsError: createError(`${ERROR_PREFIX}_NO_USER_ORGS`, 'User does not have any organisations.')
+  NoUserOrgsError: createError(`${ERROR_PREFIX}_NO_USER_ORGS`, 'User does not have any organisations.'),
 }
 
 export default errors

package/lib/resolve.js

@@ -0,0 +1,141 @@
+import { join, relative, resolve as resolvePath } from 'node:path'
+import { access, writeFile, readFile, mkdir, readdir } from 'node:fs/promises'
+import { Store, getParser, getStringifier } from '@platformatic/config'
+import { platformaticRuntime } from '@platformatic/runtime'
+import parseArgs from 'minimist'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { execa } from 'execa'
+
+const RESOLVED_SERVICES_DIRNAME = 'external'
+
+export async function resolve (argv) {
+  const args = parseArgs(argv, {
+    alias: {
+      config: 'c',
+      username: 'u',
+      password: 'p',
+    },
+    boolean: ['test'],
+    string: ['config', 'username', 'password'],
+    default: { test: false },
+  })
+
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid',
+  }))
+  try {
+    await resolveServices(args.config, logger, {
+      test: args.test,
+      username: args.username,
+      password: args.password,
+    })
+  } catch (err) {
+    console.log(err)
+    process.exit(1)
+  }
+}
+
+async function resolveServices (configPath, logger, options = {}) {
+  const store = new Store({
+    cwd: process.cwd(),
+    logger,
+  })
+  store.add(platformaticRuntime)
+
+  const { configManager } = await store.loadConfig({
+    config: configPath,
+    overrides: {
+      onMissingEnv (key) {
+        return '{' + key + '}'
+      },
+    },
+  })
+
+  configPath = configManager.fullPath
+
+  const parseConfig = getParser(configPath)
+  const configFile = await readFile(configPath, 'utf8')
+  const config = await parseConfig(configFile)
+
+  if (!config.services || config.services.length === 0) {
+    logger.info('No external services to resolve')
+    return
+  }
+
+  const projectDir = configManager.dirname
+  const externalDir = join(projectDir, RESOLVED_SERVICES_DIRNAME)
+
+  const services = config.services || []
+  for (const service of services) {
+    if (service.url) {
+      let path = service.path
+      if (path && path.startsWith('{') && path.endsWith('}')) {
+        path = await configManager.replaceEnv(path)
+
+        // Failed to resolve the path
+        if (path.startsWith('{') && path.endsWith('}')) {
+          path = null
+        }
+      }
+
+      if (!path) {
+        await mkdir(externalDir, { recursive: true })
+        path = join(externalDir, service.id)
+        service.path = relative(projectDir, path)
+      } else {
+        path = resolvePath(projectDir, path)
+      }
+
+      const isNotEmpty = await isDirectoryNotEmpty(path)
+      if (isNotEmpty) {
+        logger.info(`Skipping ${service.id} as it is not empty`)
+        continue
+      }
+
+      const relativePath = relative(projectDir, path)
+
+      logger.info(`Cloning ${service.url} into ${relativePath}`)
+      if (!options.test) {
+        let url = service.url
+        if (options.username && options.password) {
+          const urlObj = new URL(service.url)
+          if (!urlObj.username && !urlObj.password) {
+            urlObj.username = options.username
+            urlObj.password = options.password
+          }
+          url = urlObj.href
+        }
+        await execa('git', ['clone', url, path])
+      }
+
+      // TODO: replace it with a proper runtime build step
+      logger.info(`Resolving dependencies for service "${service.id}"`)
+      if (!options.test) {
+        await execa('npm', ['i'], { cwd: path })
+      }
+
+      if (!service.path) {
+        service.path = relativePath
+      }
+    }
+  }
+
+  const stringifyConfig = getStringifier(configPath)
+  const newConfig = stringifyConfig(config)
+
+  await writeFile(configManager.fullPath, newConfig, 'utf8')
+
+  logger.info('✅ All external services have been resolved')
+}
+
+async function isDirectoryNotEmpty (directoryPath) {
+  try {
+    await access(directoryPath)
+    const files = await readdir(directoryPath)
+    return files.length > 0
+  } catch (err) {
+    return false
+  }
+}

package/lib/upgrade.js

@@ -9,13 +9,13 @@ import fjs from 'fast-json-stringify'
 export async function upgrade (argv) {
   const args = parseArgs(argv, {
     alias: {
-      config: 'c'
-    }
+      config: 'c',
+    },
   })
 
   const logger = pino(pretty({
     translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid'
+    ignore: 'hostname,pid',
   }))
   try {
     await upgradeApp(args.config, logger)
@@ -28,7 +28,7 @@ export async function upgrade (argv) {
 async function upgradeApp (config, logger) {
   const store = new Store({
     cwd: process.cwd(),
-    logger
+    logger,
   })
   store.add(platformaticRuntime)
 
@@ -38,8 +38,8 @@ async function upgradeApp (config, logger) {
       fixPaths: false,
       onMissingEnv (key) {
         return '{' + key + '}'
-      }
-    }
+      },
+    },
   })
 
   await configManager.parseAndValidate(false)

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "platformatic",
-  "version": "2.0.0-alpha.2",
+  "version": "2.0.0-alpha.21",
   "description": "Platformatic CLI",
   "main": "cli.js",
   "type": "module",
@@ -27,46 +27,54 @@
     "mercurius"
   ],
   "devDependencies": {
-    "borp": "^0.16.0",
+    "add": "^2.0.6",
+    "borp": "^0.17.0",
     "c8": "^10.0.0",
-    "fastify": "^4.26.2",
+    "eslint": "9",
+    "fastify": "^5.0.0",
     "license-checker": "^25.0.1",
+    "minimatch": "^10.0.1",
     "mkdirp": "^2.1.6",
-    "snazzy": "^9.0.0",
-    "split2": "^4.2.0",
-    "standard": "^17.1.0",
+    "neostandard": "^0.11.1",
     "typescript": "^5.5.3",
-    "@platformatic/db": "2.0.0-alpha.2",
-    "@platformatic/composer": "2.0.0-alpha.2",
-    "@platformatic/service": "2.0.0-alpha.2"
+    "@platformatic/astro": "2.0.0-alpha.21",
+    "@platformatic/composer": "2.0.0-alpha.21",
+    "@platformatic/db": "2.0.0-alpha.21",
+    "@platformatic/next": "2.0.0-alpha.21",
+    "@platformatic/node": "2.0.0-alpha.21",
+    "@platformatic/remix": "2.0.0-alpha.21",
+    "@platformatic/vite": "2.0.0-alpha.21",
+    "@platformatic/service": "2.0.0-alpha.21"
   },
   "dependencies": {
-    "@fastify/error": "^3.4.1",
+    "@fastify/error": "^4.0.0",
     "colorette": "^2.0.20",
     "commist": "^3.2.0",
     "desm": "^1.3.1",
     "dotenv": "^16.4.5",
-    "execa": "^8.0.1",
+    "execa": "^9.3.1",
     "fast-json-stringify": "^5.14.1",
     "graphql": "^16.8.1",
     "help-me": "^5.0.0",
     "inquirer": "^9.2.16",
     "minimist": "^1.2.8",
-    "pino": "^8.19.0",
-    "pino-pretty": "^11.0.0",
+    "pino": "^9.4.0",
+    "pino-pretty": "^11.2.2",
+    "split2": "^4.2.0",
     "undici": "^6.9.0",
-    "@platformatic/config": "2.0.0-alpha.2",
-    "@platformatic/control": "2.0.0-alpha.2",
-    "@platformatic/db": "2.0.0-alpha.2",
-    "@platformatic/frontend-template": "2.0.0-alpha.2",
-    "@platformatic/client-cli": "2.0.0-alpha.2",
-    "create-platformatic": "2.0.0-alpha.2",
-    "@platformatic/utils": "2.0.0-alpha.2",
-    "@platformatic/runtime": "2.0.0-alpha.2"
+    "@platformatic/basic": "2.0.0-alpha.21",
+    "@platformatic/config": "2.0.0-alpha.21",
+    "@platformatic/control": "2.0.0-alpha.21",
+    "@platformatic/db": "2.0.0-alpha.21",
+    "@platformatic/runtime": "2.0.0-alpha.21",
+    "@platformatic/frontend-template": "2.0.0-alpha.21",
+    "@platformatic/client-cli": "2.0.0-alpha.21",
+    "create-platformatic": "2.0.0-alpha.21",
+    "@platformatic/utils": "2.0.0-alpha.21"
   },
   "scripts": {
-    "test": "pnpm run lint && borp --timeout 120000 --concurrency 1",
-    "lint": "standard | snazzy",
+    "test": "pnpm run lint && borp --no-timeout --concurrency 1",
+    "lint": "eslint",
     "license": "license-checker --production --onlyAllow 'Apache-2.0;MIT;ISC;BSD-2-Clause;BSD-3-Clause;CC-BY-4.0'"
   }
 }