wattpm 2.63.4 → 2.65.0

package/index.js

@@ -1,25 +1,22 @@
 import { bold } from 'colorette'
+import { adminCommand } from './lib/commands/admin.js'
 import { buildCommand, installCommand, updateCommand } from './lib/commands/build.js'
+import { createCommand } from './lib/commands/create.js'
 import { devCommand, reloadCommand, restartCommand, startCommand, stopCommand } from './lib/commands/execution.js'
 import { importCommand, resolveCommand } from './lib/commands/external.js'
 import { helpCommand } from './lib/commands/help.js'
-import { initCommand } from './lib/commands/init.js'
 import { injectCommand } from './lib/commands/inject.js'
 import { logsCommand } from './lib/commands/logs.js'
 import { configCommand, envCommand, psCommand, servicesCommand } from './lib/commands/management.js'
 import { metricsCommand } from './lib/commands/metrics.js'
 import { patchConfigCommand } from './lib/commands/patch-config.js'
-import { adminCommand } from './lib/commands/admin.js'
 import { version } from './lib/schema.js'
-import { createLogger, overrideFatal, parseArgs, setVerbose } from './lib/utils.js'
+import { createLogger, parseArgs, setVerbose } from './lib/utils.js'
 
 export async function main () {
   globalThis.platformatic = { executable: 'watt' }
-
   const logger = createLogger('info')
 
-  overrideFatal(logger)
-
   const options = {
     verbose: {
       short: 'v',
@@ -30,6 +27,7 @@ export async function main () {
       type: 'boolean'
     },
     help: {
+      short: 'h',
       type: 'boolean'
     }
   }
@@ -42,7 +40,10 @@ export async function main () {
   }
 
   if (values.help) {
-    helpCommand([])
+    helpCommand(logger, [])
+    return
+  } else if (unparsed.includes('-h') || unparsed.includes('--help')) {
+    helpCommand(logger, unparsed)
     return
   }
 
@@ -52,9 +53,6 @@ export async function main () {
 
   let command
   switch (unparsed[0]) {
-    case 'init':
-      command = initCommand
-      break
     case 'build':
       command = buildCommand
       break
@@ -112,14 +110,20 @@ export async function main () {
     case 'metrics':
       command = metricsCommand
       break
+    /* c8 ignore next - Just an alias */
+    case 'init':
+    case 'create':
+      command = createCommand
+      break
     case 'admin':
       command = adminCommand
       break
+    /* c8 ignore next 5 */
     default:
       logger.fatal(
         `Unknown command ${bold(unparsed[0])}. Please run ${bold("'wattpm help'")} to see available commands.`
       )
-      break
+      return
   }
 
   await command(logger, unparsed.slice(1))

package/lib/commands/admin.js

@@ -1,10 +1,9 @@
 import { spawn } from 'node:child_process'
-import { parseArgs } from '../utils.js'
+import { getPackageManager, parseArgs } from '../utils.js'
 
 export function adminCommand (logger, args) {
-  logger.info('Running watt-admin via npx')
-  const {
-    values: { latest },
+  let {
+    values: { latest, 'package-manager': packageManager }
   } = parseArgs(
     args,
     {
@@ -12,13 +11,33 @@ export function adminCommand (logger, args) {
         type: 'boolean',
         short: 'l'
       },
+      'package-manager': {
+        type: 'string',
+        short: 'P'
+      }
     },
     false
   )
+
+  if (!packageManager) {
+    packageManager = getPackageManager(process.cwd())
+  }
+
   const modifier = latest ? '@latest' : ''
-  const proc = spawn('npx', ['-y', '@platformatic/watt-admin' + modifier], { stdio: 'inherit' })
 
-  proc.on('exit', (code) => {
+  let command = 'npx'
+  const commandArgs = ['@platformatic/watt-admin' + modifier]
+
+  if (packageManager === 'pnpm') {
+    command = 'pnpx'
+  } else {
+    commandArgs.unshift('-y')
+  }
+
+  logger.info(`Running watt-admin via ${command} ...`)
+  const proc = spawn(command, commandArgs, { stdio: 'inherit' })
+
+  proc.on('exit', code => {
     process.exit(code)
   })
 }
@@ -30,8 +49,12 @@ export const help = {
     options: [
       {
         usage: '-l --latest',
-        description: 'Use the latest version of @platformatic/watt-admin from',
+        description: 'Use the latest version of @platformatic/watt-admin from'
       },
+      {
+        usage: 'P, --package-manager <executable>',
+        description: 'Use an alternative package manager (the default is to autodetect it)'
+      }
     ]
-  },
+  }
 }

package/lib/commands/build.js

@@ -14,7 +14,7 @@ import {
   getPackageManager,
   getRoot,
   loadConfigurationFile,
-  overrideFatal,
+  logFatalError,
   parseArgs
 } from '../utils.js'
 
@@ -34,7 +34,7 @@ async function executeCommand (root, ...args) {
     }
   }
 
-  /* c8 ignore next */
+  /* c8 ignore next - Mistakenly reported as uncovered by C8 */
   return execa(...args)
 }
 
@@ -57,9 +57,13 @@ export async function installDependencies (logger, root, services, production, p
     )
 
     await executeCommand(root, packageManager, args, { cwd: root, stdio: 'inherit' })
-    /* c8 ignore next 3 */
+    /* c8 ignore next 7 */
   } catch (error) {
-    logger.fatal({ error: ensureLoggableError(error) }, 'Unable to install dependencies of the application.')
+    return logFatalError(
+      logger,
+      { error: ensureLoggableError(error) },
+      'Unable to install dependencies of the application.'
+    )
   }
 
   for (const service of services) {
@@ -69,21 +73,26 @@ export async function installDependencies (logger, root, services, production, p
 
     try {
       logger.info(
-        `Installing ${production ? 'production ' : ''}dependencies for the service ${bold(service.id)} using ${servicePackageManager} ...`
+        `Installing ${production ? 'production ' : ''}dependencies for the service ${bold(
+          service.id
+        )} using ${servicePackageManager} ...`
       )
 
       await executeCommand(root, servicePackageManager, servicePackageArgs, {
         cwd: resolve(root, service.path),
         stdio: 'inherit'
       })
-      /* c8 ignore next 6 */
+      /* c8 ignore next 7 */
     } catch (error) {
-      logger.fatal(
+      return logFatalError(
+        logger,
         { error: ensureLoggableError(error) },
         `Unable to install dependencies of the service ${bold(service.id)}.`
       )
     }
   }
+
+  return true
 }
 
 async function updateDependencies (logger, latest, availableVersions, path, target, force) {
@@ -91,7 +100,7 @@ async function updateDependencies (logger, latest, availableVersions, path, targ
   const packageJsonPath = resolve(path, 'package.json')
 
   if (!existsSync(packageJsonPath)) {
-    return
+    return false
   }
 
   let updated = false
@@ -109,8 +118,11 @@ async function updateDependencies (logger, latest, availableVersions, path, targ
       let newRange
       if (specifier !== '^' && specifier !== '~') {
         if (!force) {
-          logger.fatal(
-            `Dependency ${bold(pkg)} of ${target}${sectionLabel} requires a non-updatable range ${bold(range)}. Try again with ${bold('-f/--force')} to update to the latest version.`
+          return logFatalError(
+            logger,
+            `Dependency ${bold(pkg)} of ${target}${sectionLabel} requires a non-updatable range ${bold(
+              range
+            )}. Try again with ${bold('-f/--force')} to update to the latest version.`
           )
         } else {
           specifier = ''
@@ -141,14 +153,32 @@ async function updateDependencies (logger, latest, availableVersions, path, targ
   if (updated) {
     await writeFile(packageJsonPath, JSON.stringify(packageJson, null, 2))
   }
+
+  return true
 }
 
 export async function buildCommand (logger, args) {
-  const { positionals } = parseArgs(args, {}, false)
-  /* c8 ignore next */
+  const {
+    values: { config },
+    positionals
+  } = parseArgs(
+    args,
+    {
+      config: {
+        type: 'string',
+        short: 'c'
+      }
+    },
+    false
+  )
   const root = getRoot(positionals)
 
-  const configurationFile = await findConfigurationFile(logger, root)
+  const configurationFile = await findConfigurationFile(logger, root, config)
+
+  /* c8 ignore next 3 - Hard to test */
+  if (!configurationFile) {
+    return
+  }
 
   const runtime = await buildRuntime(logger, configurationFile)
   // Gather informations for all services before starting
@@ -157,7 +187,6 @@ export async function buildCommand (logger, args) {
   for (const { id } of services) {
     const currentLogger = logger.child({ name: id })
     currentLogger.debug(`Building service ${bold(id)} ...`)
-    overrideFatal(currentLogger)
 
     try {
       await runtime.buildService(id)
@@ -182,11 +211,15 @@ export async function buildCommand (logger, args) {
 
 export async function installCommand (logger, args) {
   const {
-    values: { production, 'package-manager': packageManager },
+    values: { config, production, 'package-manager': packageManager },
     positionals
   } = parseArgs(
     args,
     {
+      config: {
+        type: 'string',
+        short: 'c'
+      },
       production: {
         type: 'boolean',
         short: 'p',
@@ -200,21 +233,32 @@ export async function installCommand (logger, args) {
     false
   )
 
-  /* c8 ignore next */
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root)
+  const configurationFile = await findConfigurationFile(logger, root, config)
 
-  await installDependencies(logger, root, configurationFile, production, packageManager)
-  logger.done('All services have been resolved.')
+  /* c8 ignore next 3 - Hard to test */
+  if (!configurationFile) {
+    return
+  }
+
+  const installed = await installDependencies(logger, root, configurationFile, production, packageManager)
+
+  if (installed) {
+    logger.done('All services have been resolved.')
+  }
 }
 
 export async function updateCommand (logger, args) {
   const {
     positionals,
-    values: { force }
+    values: { config, force }
   } = parseArgs(
     args,
     {
+      config: {
+        type: 'string',
+        short: 'c'
+      },
       force: {
         type: 'boolean',
         short: 'f'
@@ -223,16 +267,22 @@ export async function updateCommand (logger, args) {
     false
   )
 
-  /* c8 ignore next */
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root)
+  const configurationFile = await findConfigurationFile(logger, root, config)
+
+  /* c8 ignore next 3 - Hard to test */
+  if (!configurationFile) {
+    return
+  }
+
   const { services } = await loadConfigurationFile(logger, configurationFile)
 
   // First of all, get all version from NPM for the runtime
   const selfInfoResponse = await fetch('https://registry.npmjs.org/@platformatic/runtime')
 
   if (!selfInfoResponse.ok) {
-    logger.fatal(
+    return logFatalError(
+      logger,
       { response: selfInfoResponse.status, body: await selfInfoResponse.text() },
       'Unable to fetch version information.'
     )
@@ -266,6 +316,12 @@ export const help = {
         name: 'root',
         description: 'The directory containing the application (the default is the current directory)'
       }
+    ],
+    options: [
+      {
+        usage: '-c, --config <config>',
+        description: 'Name of the configuration file to use (the default is to autodetect it)'
+      }
     ]
   },
   install: {
@@ -278,6 +334,10 @@ export const help = {
       }
     ],
     options: [
+      {
+        usage: '-c, --config <config>',
+        description: 'Name of the configuration file to use (the default is to autodetect it)'
+      },
       {
         usage: '-p --production',
         description: 'Only install production dependencies'
@@ -298,6 +358,10 @@ export const help = {
       }
     ],
     options: [
+      {
+        usage: '-c, --config <config>',
+        description: 'Name of the configuration file to use (the default is watt.json)'
+      },
       {
         usage: '-f --force',
         description: 'Force dependencies update even if it violates the package.json version range'

package/lib/commands/create.js

@@ -0,0 +1,110 @@
+import { createApplication, getUsername, getVersion, say } from 'create-platformatic'
+import { resolve } from 'node:path'
+import { getPackageManager, parseArgs } from '../utils.js'
+import { installDependencies } from './build.js'
+
+export async function createCommand (logger, args) {
+  let {
+    values: {
+      config,
+      marketplace,
+      'package-manager': packageManager,
+      'skip-dependencies': skipDependencies,
+      module: modules
+    }
+  } = parseArgs(
+    args,
+    {
+      config: {
+        type: 'string',
+        short: 'c',
+        default: 'watt.json'
+      },
+      marketplace: {
+        type: 'string',
+        short: 'm',
+        default: 'https://marketplace.platformatic.dev'
+      },
+      'package-manager': {
+        type: 'string',
+        short: 'P'
+      },
+      'skip-dependencies': {
+        type: 'boolean',
+        short: 's',
+        default: false
+      },
+      module: {
+        short: 'M',
+        type: 'string',
+        multiple: true,
+        default: []
+      }
+    },
+    false
+  )
+
+  if (!packageManager) {
+    packageManager = getPackageManager(process.cwd())
+  }
+
+  const username = await getUsername()
+  const version = await getVersion()
+  /* c8 ignore next 2 - Ignoring else branches */
+  const greeting = username ? `Hello ${username},` : 'Hello,'
+  await say(`${greeting} welcome to ${version ? `Watt ${version}!` : 'Watt!'}`)
+
+  await createApplication(
+    logger,
+    packageManager,
+    modules.map(m => m.split(/\s*,\s*/).map(m => m.trim())).flat(),
+    marketplace,
+    skipDependencies
+      ? false
+      : (root, configurationFile, packageManager) => {
+          return installDependencies(logger, root, resolve(root, configurationFile), false, packageManager)
+        },
+    {
+      runtimeConfig: config,
+      servicesFolder: 'web'
+    }
+  )
+}
+
+const createHelp = {
+  description: 'Creates a new Watt project',
+  options: [
+    {
+      usage: '-c, --config <config>',
+      description: 'Name of the configuration file to use (the default is watt.json)'
+    },
+    {
+      usage: '-m, --marketplace <url>',
+      description: 'Platformatic Marketplace host (the default is https://marketplace.platformatic.dev)'
+    },
+    {
+      usage: '-s, --skip-dependencies',
+      description: 'Do not install dependencies after creating the files'
+    },
+    {
+      usage: '-P, --package-manager <executable>',
+      description: 'Use an alternative package manager (the default is to autodetect it)'
+    },
+    {
+      usage: '-M, --module <name>',
+      description:
+        'An additional module (or a comma separated list of modules) to use as service generator (it can be used multiple times)'
+    }
+  ]
+}
+
+export const help = {
+  init: {
+    usage: 'init',
+    ...createHelp
+  },
+  create: {
+    usage: 'create',
+    ...createHelp
+  }
+}

package/lib/commands/execution.js

@@ -4,14 +4,31 @@ import { ensureLoggableError } from '@platformatic/utils'
 import { bold } from 'colorette'
 import { spawn } from 'node:child_process'
 import { watch } from 'node:fs/promises'
-import { findConfigurationFile, getMatchingRuntime, getRoot, parseArgs } from '../utils.js'
+import { findConfigurationFile, getMatchingRuntime, getRoot, logFatalError, parseArgs } from '../utils.js'
 
 export async function devCommand (logger, args) {
-  const { positionals } = parseArgs(args, {}, false)
-  /* c8 ignore next */
+  const {
+    values: { config },
+    positionals
+  } = parseArgs(
+    args,
+    {
+      config: {
+        type: 'string',
+        short: 'c'
+      }
+    },
+    false
+  )
   const root = getRoot(positionals)
 
-  const configurationFile = await findConfigurationFile(logger, root)
+  const configurationFile = await findConfigurationFile(logger, root, config)
+
+  /* c8 ignore next 3 - Hard to test */
+  if (!configurationFile) {
+    return
+  }
+
   let runtime = await pltStartCommand(['-c', configurationFile], true, true)
 
   // Add a watcher on the configurationFile so that we can eventually restart the runtime
@@ -22,30 +39,38 @@ export async function devCommand (logger, args) {
     await runtime.close()
     runtime = await pltStartCommand(['-c', configurationFile], true, true)
   }
-  /* c8 ignore next */
+  /* c8 ignore next - Mistakenly reported as uncovered by C8 */
 }
 
 export async function startCommand (logger, args) {
-  const { positionals, values } = parseArgs(
+  const {
+    positionals,
+    values: { inspect, config }
+  } = parseArgs(
     args,
     {
-      inspect: {
-        type: 'boolean',
-        short: 'i'
-      },
       config: {
         type: 'string',
         short: 'c'
+      },
+      inspect: {
+        type: 'boolean',
+        short: 'i'
       }
     },
     false
   )
-  /* c8 ignore next */
+
   const root = getRoot(positionals)
+  const configurationFile = await findConfigurationFile(logger, root, config)
+
+  /* c8 ignore next 3 - Hard to test */
+  if (!configurationFile) {
+    return
+  }
 
-  const configurationFile = await findConfigurationFile(logger, root, values.config)
   const cmd = ['--production', '-c', configurationFile]
-  if (values.inspect) {
+  if (inspect) {
     cmd.push('--inspect')
   }
   await pltStartCommand(cmd, true)
@@ -64,10 +89,10 @@ export async function stopCommand (logger, args) {
     logger.done(`Runtime ${bold(runtime.packageName)} have been stopped.`)
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
-      logger.fatal('Cannot find a matching runtime.')
-      /* c8 ignore next 3 */
+      return logFatalError(logger, 'Cannot find a matching runtime.')
+      /* c8 ignore next 3 - Hard to test */
     } else {
-      logger.fatal({ error: ensureLoggableError(error) }, `Cannot stop the runtime: ${error.message}`)
+      return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot stop the runtime: ${error.message}`)
     }
   }
 }
@@ -85,10 +110,14 @@ export async function restartCommand (logger, args) {
     logger.done(`Runtime ${bold(runtime.packageName)} has been restarted.`)
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
-      logger.fatal('Cannot find a matching runtime.')
-      /* c8 ignore next 3 */
+      return logFatalError(logger, 'Cannot find a matching runtime.')
+      /* c8 ignore next 7 - Hard to test */
     } else {
-      logger.fatal({ error: ensureLoggableError(error) }, `Cannot restart the runtime: ${error.message}`)
+      return logFatalError(
+        logger,
+        { error: ensureLoggableError(error) },
+        `Cannot restart the runtime: ${error.message}`
+      )
     }
   }
 }
@@ -119,10 +148,10 @@ export async function reloadCommand (logger, args) {
     logger.done(`Runtime ${bold(runtime.packageName)} have been reloaded and it is now running as PID ${child.pid}.`)
   } catch (error) {
     if (error.code === 'PLT_CTR_RUNTIME_NOT_FOUND') {
-      logger.fatal('Cannot find a matching runtime.')
-      /* c8 ignore next 3 */
+      return logFatalError(logger, 'Cannot find a matching runtime.')
+      /* c8 ignore next 3 - Hard to test */
     } else {
-      logger.fatal({ error: ensureLoggableError(error) }, `Cannot reload the runtime: ${error.message}`)
+      return logFatalError(logger, { error: ensureLoggableError(error) }, `Cannot reload the runtime: ${error.message}`)
     }
   }
 }
@@ -136,6 +165,12 @@ export const help = {
         name: 'root',
         description: 'The directory containing the application (the default is the current directory)'
       }
+    ],
+    options: [
+      {
+        usage: '-c, --config <config>',
+        description: 'Name of the configuration file to use (the default to autodetect it)'
+      }
     ]
   },
   start: {
@@ -148,6 +183,10 @@ export const help = {
       }
     ],
     options: [
+      {
+        usage: '-c, --config <config>',
+        description: 'Name of the configuration file to use (the default to autodetect it)'
+      },
       {
         usage: '-i --inspect',
         description: 'Enables the inspector for each service'