wattpm 2.66.0 → 2.67.0-alpha.0

package/index.js

@@ -11,7 +11,7 @@ import { configCommand, envCommand, psCommand, servicesCommand } from './lib/com
 import { metricsCommand } from './lib/commands/metrics.js'
 import { patchConfigCommand } from './lib/commands/patch-config.js'
 import { version } from './lib/schema.js'
-import { createLogger, parseArgs, setVerbose } from './lib/utils.js'
+import { createLogger, logFatalError, parseArgs, setVerbose } from './lib/utils.js'
 
 export async function main () {
   globalThis.platformatic = { executable: 'watt' }
@@ -52,7 +52,7 @@ export async function main () {
   }
 
   let command
-  switch (unparsed[0]) {
+  switch (unparsed[0] || 'help') {
     case 'build':
       command = buildCommand
       break
@@ -118,12 +118,13 @@ export async function main () {
     case 'admin':
       command = adminCommand
       break
-    /* c8 ignore next 5 */
     default:
-      logger.fatal(
+      logFatalError(
+        logger,
         `Unknown command ${bold(unparsed[0])}. Please run ${bold("'wattpm help'")} to see available commands.`
       )
-      return
+
+      break
   }
 
   await command(logger, unparsed.slice(1))

package/lib/commands/build.js

@@ -9,11 +9,11 @@ import { rsort, satisfies } from 'semver'
 import { packages } from '../packages.js'
 import {
   buildRuntime,
-  findConfigurationFile,
+  findRuntimeConfigurationFile,
   getPackageArgs,
   getPackageManager,
   getRoot,
-  loadConfigurationFile,
+  loadRuntimeConfigurationFile,
   logFatalError,
   parseArgs
 } from '../utils.js'
@@ -40,7 +40,7 @@ async function executeCommand (root, ...args) {
 
 export async function installDependencies (logger, root, services, production, packageManager) {
   if (typeof services === 'string') {
-    const config = await loadConfigurationFile(logger, services)
+    const config = await loadRuntimeConfigurationFile(logger, services)
     services = config.services
   }
 
@@ -158,55 +158,68 @@ async function updateDependencies (logger, latest, availableVersions, path, targ
 }
 
 export async function buildCommand (logger, args) {
-  const {
-    values: { config },
-    positionals
-  } = parseArgs(
-    args,
-    {
-      config: {
-        type: 'string',
-        short: 'c'
-      }
-    },
-    false
-  )
-  const root = getRoot(positionals)
+  let runtime
 
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  try {
+    const {
+      values: { config },
+      positionals
+    } = parseArgs(
+      args,
+      {
+        config: {
+          type: 'string',
+          short: 'c'
+        }
+      },
+      false
+    )
+    const root = getRoot(positionals)
 
-  /* c8 ignore next 3 - Hard to test */
-  if (!configurationFile) {
-    return
-  }
+    const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
-  const runtime = await buildRuntime(logger, configurationFile)
-  // Gather informations for all services before starting
-  const { services } = await runtime.getServices()
+    /* c8 ignore next 3 - Hard to test */
+    if (!configurationFile) {
+      return
+    }
 
-  for (const { id } of services) {
-    const currentLogger = logger.child({ name: id })
-    currentLogger.debug(`Building service ${bold(id)} ...`)
+    runtime = await buildRuntime(logger, configurationFile)
 
-    try {
-      await runtime.buildService(id)
-    } 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}`
-        )
-      }
+    /* c8 ignore next 3 - Hard to test */
+    if (!runtime) {
+      return
+    }
+
+    // Gather informations for all services before starting
+    const { services } = await runtime.getServices()
 
-      process.exit(1)
+    for (const { id } of services) {
+      const currentLogger = logger.child({ name: id })
+      currentLogger.debug(`Building service ${bold(id)} ...`)
+
+      try {
+        await runtime.buildService(id)
+      } catch (error) {
+        if (error.code === 'PLT_BASIC_NON_ZERO_EXIT_CODE') {
+          logFatalError(currentLogger, `Building service "${id}" has failed with exit code ${error.exitCode}.`)
+          /* c8 ignore next 6 */
+        } else {
+          logFatalError(
+            currentLogger,
+            { err: ensureLoggableError(error) },
+            `Building service "${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(true)
+    logger.done('All services have been built.')
+  } finally {
+    await runtime?.close?.(true)
+  }
 }
 
 export async function installCommand (logger, args) {
@@ -234,7 +247,7 @@ export async function installCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -268,14 +281,14 @@ export async function updateCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
     return
   }
 
-  const { services } = await loadConfigurationFile(logger, configurationFile)
+  const { services } = await loadRuntimeConfigurationFile(logger, configurationFile)
 
   // First of all, get all version from NPM for the runtime
   const selfInfoResponse = await fetch('https://registry.npmjs.org/@platformatic/runtime')

package/lib/commands/execution.js

@@ -4,7 +4,7 @@ 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, logFatalError, parseArgs } from '../utils.js'
+import { findRuntimeConfigurationFile, getMatchingRuntime, getRoot, logFatalError, parseArgs } from '../utils.js'
 
 export async function devCommand (logger, args) {
   const {
@@ -22,7 +22,7 @@ export async function devCommand (logger, args) {
   )
   const root = getRoot(positionals)
 
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -62,7 +62,7 @@ export async function startCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {

package/lib/commands/external.js

@@ -9,9 +9,9 @@ import { readFile, writeFile } from 'node:fs/promises'
 import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path'
 import { version } from '../schema.js'
 import {
-  findConfigurationFile,
+  findRuntimeConfigurationFile,
   getRoot,
-  loadConfigurationFile,
+  loadRuntimeConfigurationFile,
   logFatalError,
   parseArgs,
   serviceToEnvVariable
@@ -89,20 +89,19 @@ export async function appendEnvVariable (envFile, key, value) {
 }
 
 async function fixConfiguration (logger, root, configOption) {
-  const configurationFile = await findConfigurationFile(logger, root, configOption)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, configOption)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
     return
   }
 
-  const config = await loadConfigurationFile(logger, configurationFile)
+  const config = await loadRuntimeConfigurationFile(logger, configurationFile)
 
   // For each service, if there is no watt.json, create one and fix package dependencies
   for (const { path } of config.services) {
     const wattConfiguration = await findExistingConfiguration(root, path)
 
-    /* c8 ignore next 3 - Hard to test */
     if (wattConfiguration) {
       continue
     }
@@ -124,7 +123,7 @@ async function fixConfiguration (logger, root, configOption) {
 }
 
 async function importService (logger, configurationFile, id, path, url, branch) {
-  const config = await loadConfigurationFile(logger, configurationFile)
+  const config = await loadRuntimeConfigurationFile(logger, configurationFile)
   const rawConfig = await loadRawConfigurationFile(configurationFile)
   const root = dirname(configurationFile)
   const envFile = resolve(root, '.env')
@@ -260,7 +259,7 @@ export async function resolveServices (
   skipDependencies,
   packageManager
 ) {
-  const config = await loadConfigurationFile(logger, configurationFile)
+  const config = await loadRuntimeConfigurationFile(logger, configurationFile)
 
   // The services which might be to be resolved are the one that have a URL and either
   // no path defined (which means no environment variable set) or a non-existing path (which means not resolved yet)
@@ -407,7 +406,7 @@ export async function importCommand (logger, args) {
     rawUrl = positionals[1]
   }
 
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {
@@ -462,7 +461,7 @@ export async function resolveCommand (logger, args) {
   )
 
   const root = getRoot(positionals)
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 - Hard to test */
   if (!configurationFile) {

package/lib/commands/patch-config.js

@@ -1,11 +1,25 @@
-import { ConfigManager, getParser, getStringifier } from '@platformatic/config'
-import { ensureLoggableError, loadModule } from '@platformatic/utils'
+import {
+  ConfigManager,
+  getParser,
+  getStringifier,
+  loadConfigurationFile,
+  saveConfigurationFile
+} from '@platformatic/config'
+import { ensureLoggableError, loadModule, safeRemove } from '@platformatic/utils'
 import jsonPatch from 'fast-json-patch'
 import { existsSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
+import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
 import { createRequire } from 'node:module'
+import { tmpdir } from 'node:os'
 import { resolve } from 'node:path'
-import { buildRuntime, findConfigurationFile, getRoot, logFatalError, parseArgs } from '../utils.js'
+import {
+  buildRuntime,
+  findRuntimeConfigurationFile,
+  getRoot,
+  loadConfigurationFileAsConfig,
+  logFatalError,
+  parseArgs
+} from '../utils.js'
 
 async function patchFile (path, patch) {
   let config = getParser(path)(await readFile(path, 'utf-8'))
@@ -16,7 +30,11 @@ async function patchFile (path, patch) {
 export async function patchConfig (logger, configurationFile, patchPath) {
   let runtime
   try {
-    const patchFunction = await loadModule(createRequire(import.meta.url), patchPath)
+    // Determine if the configuration file is for a service or a runtime
+    const config = await loadConfigurationFileAsConfig(logger, configurationFile)
+    const isService = config.configType !== 'runtime'
+
+    const patchFunction = await loadModule(createRequire(configurationFile), patchPath)
 
     if (typeof patchFunction !== 'function') {
       throw new Error('Patch file must export a function.')
@@ -25,6 +43,11 @@ export async function patchConfig (logger, configurationFile, patchPath) {
     // Create the runtime
     runtime = await buildRuntime(logger, configurationFile)
 
+    /* c8 ignore next 3 - Hard to test */
+    if (!runtime) {
+      return
+    }
+
     // Prepare the structure for original and modified configurations files
     const original = {
       runtime: getParser(configurationFile)(await readFile(configurationFile, 'utf-8')),
@@ -64,7 +87,24 @@ export async function patchConfig (logger, configurationFile, patchPath) {
     }
 
     if (Array.isArray(patches.runtime)) {
-      await patchFile(configurationFile, patches.runtime)
+      if (isService) {
+        // Create a temporary file with existing configuration
+        const temporaryDir = await mkdtemp(resolve(tmpdir(), 'wattpm-patch-'))
+        const temporaryFile = resolve(temporaryDir, 'watt.json')
+
+        try {
+          /* c8 ignore next - Else branch */
+          await saveConfigurationFile(temporaryFile, original.runtime.runtime ?? {})
+          await patchFile(temporaryFile, patches.runtime)
+          await patchFile(configurationFile, [
+            { op: 'replace', path: '/runtime', value: await loadConfigurationFile(temporaryFile) }
+          ])
+        } finally {
+          await safeRemove(temporaryDir)
+        }
+      } else {
+        await patchFile(configurationFile, patches.runtime)
+      }
     }
 
     if (typeof patches.services === 'object') {
@@ -77,7 +117,7 @@ export async function patchConfig (logger, configurationFile, patchPath) {
       }
     }
   } finally {
-    await runtime?.close?.(false, true)
+    await runtime?.close?.(true)
   }
 }
 
@@ -113,7 +153,7 @@ export async function patchConfigCommand (logger, args) {
     patch = positionals[1]
   }
 
-  const configurationFile = await findConfigurationFile(logger, root, config)
+  const configurationFile = await findRuntimeConfigurationFile(logger, root, config)
 
   /* c8 ignore next 3 */
   if (!configurationFile) {

package/lib/logo.js

@@ -30,7 +30,7 @@ const str = `
                               &&&&&&&&&&&&&
                                   &&&&&&
 
-                          Welcome to ${bold('Watt')}!
+                            Welcome to ${bold('Watt')}!
 `
 
 export const logo = str.replace(/\//g, s => green(s))

package/lib/utils.js

@@ -1,10 +1,7 @@
-import {
-  findConfigurationFile as findRawConfigurationFile,
-  loadConfig as pltConfigLoadConfig,
-  Store
-} from '@platformatic/config'
+import { findConfigurationFile, loadConfig, Store } from '@platformatic/config'
 import { errors } from '@platformatic/control'
-import { platformaticRuntime, buildRuntime as pltBuildRuntime } from '@platformatic/runtime'
+import { platformaticRuntime, buildRuntime as pltBuildRuntime, wrapConfigInRuntimeConfig } from '@platformatic/runtime'
+import { ensureLoggableError } from '@platformatic/utils'
 import { bgGreen, black, bold } from 'colorette'
 import { existsSync } from 'node:fs'
 import { resolve } from 'node:path'
@@ -156,8 +153,13 @@ export function serviceToEnvVariable (service) {
   return `PLT_SERVICE_${service.toUpperCase().replaceAll(/[^A-Z0-9_]/g, '_')}_PATH`
 }
 
-export async function findConfigurationFile (logger, root, configurationFile, schemas = 'runtime') {
-  const configFile = await findRawConfigurationFile(root, configurationFile, schemas)
+export async function findRuntimeConfigurationFile (logger, root, configurationFile, schemas = 'runtime') {
+  let configFile = await findConfigurationFile(root, configurationFile, schemas)
+
+  // If a runtime was not found, search for service file that we wrap in a runtime
+  if (schemas === 'runtime' && !configFile && !configurationFile) {
+    configFile = await findConfigurationFile(root, configurationFile)
+  }
 
   if (!configFile) {
     return logFatalError(
@@ -171,39 +173,64 @@ export async function findConfigurationFile (logger, root, configurationFile, sc
   return configFile
 }
 
-export async function loadConfigurationFile (logger, configurationFile) {
-  const store = new Store({
-    cwd: process.cwd(),
-    logger
-  })
+export async function loadConfigurationFileAsConfig (logger, configurationFile) {
+  const store = new Store()
   store.add(platformaticRuntime)
 
-  const { configManager } = await store.loadConfig({
-    config: configurationFile,
-    overrides: {
+  const args = ['-c', configurationFile]
+  const options = { allowInvalid: true, transformOnValidationErrors: true }
+  return loadConfig(
+    {},
+    args,
+    store,
+    {
       /* c8 ignore next 3 */
-      onMissingEnv (key) {
+      onMissingEnv () {
         return ''
       }
-    }
-  })
+    },
+    true,
+    logger,
+    options
+  )
+}
 
-  await configManager.parse(true, [], { transformOnValidationErrors: true })
-  return configManager.current
+export async function loadRuntimeConfigurationFile (logger, configurationFile) {
+  const config = await loadConfigurationFileAsConfig(logger, configurationFile)
+  const args = ['-c', configurationFile]
+  const options = { allowInvalid: true, transformOnValidationErrors: true }
+
+  if (config.configType !== 'runtime') {
+    const configManager = await wrapConfigInRuntimeConfig(config, args, options)
+    config.configManager = configManager
+  }
+
+  config.configManager.args = config.args
+
+  return config.configManager.current
 }
 
 export async function buildRuntime (logger, configurationFile) {
   const store = new Store()
   store.add(platformaticRuntime)
 
-  const config = await pltConfigLoadConfig({}, ['-c', configurationFile], store, {}, true, logger)
+  const args = ['-c', configurationFile]
+  const config = await loadConfig({}, args, store, {}, true, logger)
+
+  if (config.configType !== 'runtime') {
+    const configManager = await wrapConfigInRuntimeConfig(config, args)
+    config.configManager = configManager
+  }
+
   config.configManager.args = config.args
 
-  const runtimeConfig = config.configManager
+  let runtime
   try {
-    return await pltBuildRuntime(runtimeConfig)
+    runtime = await pltBuildRuntime(config.configManager)
     /* c8 ignore next 3 - Hard to test */
-  } catch (e) {
-    process.exit(1)
+  } catch (error) {
+    logFatalError(logger, { err: ensureLoggableError(error) }, 'Error creating the runtime')
   }
+
+  return runtime
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattpm",
-  "version": "2.66.0",
+  "version": "2.67.0-alpha.0",
   "description": "The Node.js Application Server",
   "main": "index.js",
   "type": "module",
@@ -36,12 +36,12 @@
     "semver": "^7.7.0",
     "split2": "^4.2.0",
     "table": "^6.8.2",
-    "@platformatic/basic": "2.66.0",
-    "@platformatic/config": "2.66.0",
-    "@platformatic/runtime": "2.66.0",
-    "@platformatic/utils": "2.66.0",
-    "create-platformatic": "2.66.0",
-    "@platformatic/control": "2.66.0"
+    "@platformatic/basic": "2.67.0-alpha.0",
+    "@platformatic/config": "2.67.0-alpha.0",
+    "@platformatic/control": "2.67.0-alpha.0",
+    "@platformatic/runtime": "2.67.0-alpha.0",
+    "@platformatic/utils": "2.67.0-alpha.0",
+    "create-platformatic": "2.67.0-alpha.0"
   },
   "devDependencies": {
     "borp": "^0.20.0",
@@ -51,7 +51,7 @@
     "neostandard": "^0.12.0",
     "typescript": "^5.5.4",
     "undici": "^7.0.0",
-    "@platformatic/node": "2.66.0"
+    "@platformatic/node": "2.67.0-alpha.0"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=300000",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/wattpm/2.66.0.json",
+  "$id": "https://schemas.platformatic.dev/wattpm/2.67.0-alpha.0.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {