wattpm 3.4.1 → 3.5.1

package/README.md

@@ -0,0 +1,46 @@
+![The Platformatic logo](https://github.com/platformatic/platformatic/raw/HEAD/assets/banner-light.png)
+
+# Watt, the Application Server for Node.js
+
+[![npm](https://img.shields.io/npm/v/wattpm)](https://www.npmjs.com/package/wattpm)
+[![CI](https://github.com/platformatic/platformatic/actions/workflows/ci.yml/badge.svg)](https://github.com/platformatic/platformatic/actions/workflows/ci.yml)
+[![NPM version](https://img.shields.io/npm/v/platformatic.svg?style=flat)](https://www.npmjs.com/package/platformatic)
+[![Discord](https://img.shields.io/discord/1011258196905689118)](https://discord.gg/platformatic)
+
+Watt, Platformatic's Node.js application server, allows you to run multiple Node.js applications that are centrally managed.
+
+By using Watt, you gain access to a virtual mesh network, fast logging via [Pino](https://getpino.io/),
+monitoring through [Prometheus](https://prometheus.io/), and [OpenTelemetry](https://opentelemetry.io/) integrations.
+
+Watt supports the stacks you love most, including [Next.js](https://nextjs.org/), [Astro](https://astro.build/),
+[Express](https://expressjs.com/), and [Fastify](https://fastify.dev/).
+
+## Install
+
+```bash
+# Create a new application
+npx wattpm@latest init
+
+# Or install manually:
+npm install wattpm
+```
+
+Follow our [Quick Start Guide](https://docs.platformatic.dev/docs/getting-started/quick-start)
+guide to get up and running with Platformatic.
+
+## Documentation
+
+- [Getting Started](https://docs.platformatic.dev/docs/getting-started/quick-start)
+- [Reference](https://docs.platformatic.dev/docs/reference/wattpm/overview)
+- [Guides](https://docs.platformatic.dev/docs/guides/build-modular-monolith)
+
+Check out our full documentation at [platformatic.dev](https://platformatic.dev).
+
+## Support
+
+If you run into a bug, issues or have a suggestion for improvement, please raise an
+[issue on GitHub](https://github.com/platformatic/platformatic/issues/new) or join our [Discord feedback](https://discord.gg/platformatic) channel.
+
+## License
+
+[Apache 2.0](../../LICENSE)

package/bin/cli.js

@@ -0,0 +1,11 @@
+#!/usr/bin/env node
+
+import { checkNodeVersionForApplications, setExecutableId, setExecutableName } from '@platformatic/foundation'
+
+checkNodeVersionForApplications()
+setExecutableId('wattpm')
+setExecutableName('Watt')
+
+// Use await import here so that we can throw a proper error on unsupported Node.js version
+const { main } = await import('../index.js')
+await main()

package/index.js

@@ -1,19 +1,25 @@
+import { createCliLogger, getExecutableId, logFatalError, parseArgs, setVerbose } from '@platformatic/foundation'
+import { loadApplicationsCommands } from '@platformatic/runtime'
+import * as colorette from 'colorette'
 import { bold } from 'colorette'
+import { adminCommand } from './lib/commands/admin.js'
 import { buildCommand } 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 { applicationsCommand, configCommand, envCommand, psCommand } from './lib/commands/management.js'
+import { metricsCommand } from './lib/commands/metrics.js'
+import { pprofCommand } from './lib/commands/pprof.js'
 import { version } from './lib/schema.js'
-import { createLogger, overrideFatal, parseArgs, setVerbose } from './lib/utils.js'
+
+export * from './lib/schema.js'
 
 export async function main () {
-  const logger = createLogger('info')
+  globalThis.platformatic = { executable: getExecutableId() }
 
-  overrideFatal(logger)
+  const logger = createCliLogger('info')
 
   const options = {
     verbose: {
@@ -25,6 +31,7 @@ export async function main () {
       type: 'boolean'
     },
     help: {
+      short: 'h',
       type: 'boolean'
     }
   }
@@ -37,7 +44,10 @@ export async function main () {
   }
 
   if (values.help) {
-    helpCommand([])
+    helpCommand(logger, [])
+    return
+  } else if (unparsed.includes('-h') || unparsed.includes('--help')) {
+    helpCommand(logger, unparsed)
     return
   }
 
@@ -46,10 +56,9 @@ export async function main () {
   }
 
   let command
-  switch (unparsed[0]) {
-    case 'init':
-      command = initCommand
-      break
+  const requestedCommand = unparsed[0] || 'help'
+  let applicationCommandContext
+  switch (requestedCommand) {
     case 'build':
       command = buildCommand
       break
@@ -71,8 +80,8 @@ export async function main () {
     case 'ps':
       command = psCommand
       break
-    case 'services':
-      command = servicesCommand
+    case 'applications':
+      command = applicationsCommand
       break
     case 'config':
       command = configCommand
@@ -86,23 +95,51 @@ export async function main () {
     case 'inject':
       command = injectCommand
       break
-    case 'import':
-      command = importCommand
+    case 'metrics':
+      command = metricsCommand
       break
-    case 'resolve':
-      command = resolveCommand
+    case 'pprof':
+      command = pprofCommand
+      break
+    case 'admin':
+      command = adminCommand
+      break
+    /* c8 ignore next 2 - aliases */
+    case 'init':
+    case 'add':
+    case 'create':
+      command = createCommand
       break
     case 'help':
       command = helpCommand
       break
     default:
-      logger.fatal(
-        `Unknown command ${bold(unparsed[0])}. Please run ${bold("'wattpm help'")} to see available commands.`
-      )
+      if (requestedCommand) {
+        const applicationsCommands = await loadApplicationsCommands()
+        const applicationCommand = applicationsCommands.commands[requestedCommand]
+
+        if (applicationCommand) {
+          applicationCommandContext = applicationsCommands.applications[requestedCommand]
+          command = applicationCommand
+        }
+      }
+
       break
   }
 
-  await command(logger, unparsed.slice(1))
-}
+  if (!command) {
+    logFatalError(
+      logger,
+      `Unknown command ${bold(requestedCommand)}. Please run ${bold(`"${getExecutableId()} help"`)} to see available commands.`
+    )
 
-export * from './lib/schema.js'
+    return
+  }
+
+  if (applicationCommandContext) {
+    process.chdir(applicationCommandContext.path)
+    return command(logger, applicationCommandContext.config, unparsed.slice(1), { colorette, parseArgs, logFatalError })
+  } else {
+    await command(logger, unparsed.slice(1))
+  }
+}

package/lib/commands/admin.js

@@ -0,0 +1,40 @@
+import { parseArgs } from '@platformatic/foundation'
+import { runDelegatedCommand } from './create.js'
+
+export async function adminCommand (logger, args) {
+  const {
+    values: { latest, 'package-manager': packageManager }
+  } = parseArgs(
+    args,
+    {
+      latest: {
+        type: 'boolean',
+        short: 'l'
+      },
+      'package-manager': {
+        type: 'string',
+        short: 'P'
+      }
+    },
+    false
+  )
+
+  return runDelegatedCommand(logger, packageManager, ['@platformatic/watt-admin' + (latest ? '@latest' : '')])
+}
+
+export const help = {
+  admin: {
+    usage: 'admin',
+    description: 'Start the admin interface',
+    options: [
+      {
+        usage: '-l --latest',
+        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

@@ -1,53 +1,95 @@
-import { ensureLoggableError } from '@platformatic/utils'
+import {
+  ensureLoggableError,
+  findRuntimeConfigurationFile,
+  getRoot,
+  logFatalError,
+  parseArgs
+} from '@platformatic/foundation'
+import { create } from '@platformatic/runtime'
 import { bold } from 'colorette'
-import { resolve } from 'node:path'
-import { buildRuntime, findConfigurationFile, overrideFatal, parseArgs } from '../utils.js'
 
 export async function buildCommand (logger, args) {
-  const { positionals } = parseArgs(args, {}, false)
-  /* c8 ignore next */
-  const root = resolve(process.cwd(), positionals[0] ?? '')
+  let runtime
+  let configurationFile
 
-  const configurationFile = await findConfigurationFile(logger, root)
+  try {
+    const {
+      values: { config },
+      positionals
+    } = parseArgs(
+      args,
+      {
+        config: {
+          type: 'string',
+          short: 'c'
+        }
+      },
+      false
+    )
+    const root = getRoot(positionals)
 
-  const runtime = await buildRuntime(logger, configurationFile)
-  // Gather informations for all services before starting
-  const { services } = await runtime.getServices()
+    configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
-  for (const { id } of services) {
-    const currentLogger = logger.child({ name: id })
-    currentLogger.debug(`Building service ${bold(id)} ...`)
-    overrideFatal(currentLogger)
+    /* c8 ignore next 3 - Hard to test */
+    if (!configurationFile) {
+      return
+    }
 
     try {
-      await runtime.buildService(id)
+      runtime = await create(configurationFile)
+      await runtime.init()
+      /* c8 ignore next 4 - Hard to test */
     } catch (error) {
-      if (error.code === 'PLT_BASIC_NON_ZERO_EXIT_CODE') {
-        currentLogger.error(`Building service "${id}" has failed with exit code ${error.exitCode}.`)
-        /* c8 ignore next 6 */
-      } else {
-        currentLogger.error(
-          { err: ensureLoggableError(error) },
-          `Building service "${id}" has throw an exception: ${error.message}`
-        )
-      }
+      logFatalError(logger, { err: ensureLoggableError(error) }, `Cannot load the runtime: ${error.message}`)
+      return
+    }
+
+    // Gather informations for all applications before starting
+    const { applications } = await runtime.getApplications()
+
+    for (const { id } of applications) {
+      const currentLogger = logger.child({ name: id })
+      currentLogger.debug(`Building application ${bold(id)} ...`)
 
-      process.exit(1)
+      try {
+        await runtime.buildApplication(id)
+      } catch (error) {
+        if (error.code === 'PLT_BASIC_NON_ZERO_EXIT_CODE') {
+          logFatalError(currentLogger, `Building application "${id}" has failed with exit code ${error.exitCode}.`)
+          /* c8 ignore next 6 */
+        } else {
+          logFatalError(
+            currentLogger,
+            { err: ensureLoggableError(error) },
+            `Building application "${id}" has throw an exception: ${error.message}`
+          )
+          /* c8 ignore next 3 - Mistakenly reported as uncovered by C8 */
+        }
+
+        return
+      }
     }
-  }
 
-  logger.done('All services have been built.')
-  await runtime.close(false, true)
+    logger.done('All applications have been built.')
+  } finally {
+    await runtime?.close?.(true)
+  }
 }
 
 export const help = {
   build: {
     usage: 'build [root]',
-    description: 'Builds all services of an application',
+    description: 'Builds all applications of the project',
     args: [
       {
         name: 'root',
-        description: 'The directory containing the application (the default is the current directory)'
+        description: 'The directory containing the project (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)'
       }
     ]
   }

package/lib/commands/create.js

@@ -0,0 +1,139 @@
+import { getExecutableName, getPackageManager, parseArgs } from '@platformatic/foundation'
+import { bold } from 'colorette'
+import { spawn } from 'node:child_process'
+import { platform } from 'node:os'
+
+export async function runDelegatedCommand (logger, packageManager, args) {
+  if (!packageManager) {
+    packageManager = await getPackageManager(process.cwd())
+  }
+
+  let runner = 'npx'
+  if (packageManager === 'pnpm') {
+    runner = 'pnpx'
+  } else {
+    args.unshift('-y')
+  }
+
+  logger.info(`Running ${bold(runner)} ${bold(args.join(' '))} ...`)
+
+  const options = { stdio: 'inherit' }
+
+  if (platform() === 'win32') {
+    options.shell = true
+    options.windowsVerbatimArguments = true
+  }
+
+  const proc = spawn(runner, args, options)
+
+  proc.on('exit', code => {
+    process.exit(code)
+  })
+}
+
+export async function createCommand (logger, args) {
+  const {
+    values: {
+      latest,
+      config,
+      'package-manager': packageManager,
+      'skip-dependencies': skipDependencies,
+      module: modules
+    }
+  } = parseArgs(
+    args,
+    {
+      latest: {
+        type: 'boolean',
+        short: 'l'
+      },
+      // Keep following options in sync with the create command from wattpm-utils
+      config: {
+        type: 'string',
+        short: 'c',
+        default: 'watt.json'
+      },
+      'package-manager': {
+        type: 'string',
+        short: 'P'
+      },
+      'skip-dependencies': {
+        type: 'boolean',
+        short: 's',
+        default: false
+      },
+      module: {
+        short: 'M',
+        type: 'string',
+        multiple: true,
+        default: []
+      }
+    },
+    false,
+    false
+  )
+
+  const runArgs = ['wattpm-utils' + (latest ? '@latest' : ''), '--', 'create']
+
+  runArgs.push('-c', config)
+
+  if (packageManager) {
+    runArgs.push('-P', packageManager)
+  }
+
+  if (skipDependencies) {
+    runArgs.push('-s')
+  }
+
+  if (modules.length > 0) {
+    for (const m of modules) {
+      runArgs.push('-M', m)
+    }
+  }
+
+  return runDelegatedCommand(logger, packageManager, runArgs)
+}
+
+const createHelp = {
+  description () {
+    return `Creates a new ${getExecutableName()} project`
+  },
+  options: [
+    {
+      usage: '-l --latest',
+      description: 'Use the latest version of @platformatic/watt-admin from'
+    },
+    {
+      usage: '-c, --config <config>',
+      description: 'Name of the configuration file to use (the default is watt.json)'
+    },
+    {
+      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 application generator (it can be used multiple times)'
+    }
+  ]
+}
+
+export const help = {
+  init: {
+    usage: 'init',
+    ...createHelp
+  },
+  create: {
+    usage: 'create',
+    ...createHelp
+  },
+  add: {
+    usage: 'add',
+    ...createHelp
+  }
+}