wattpm 2.19.0 → 2.20.0-alpha.2

package/index.js

@@ -1,5 +1,5 @@
 import { bold } from 'colorette'
-import { buildCommand } from './lib/commands/build.js'
+import { buildCommand, installCommand } from './lib/commands/build.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'
@@ -11,6 +11,8 @@ import { version } from './lib/schema.js'
 import { createLogger, overrideFatal, parseArgs, setVerbose } from './lib/utils.js'
 
 export async function main () {
+  globalThis.platformatic = { executable: 'watt' }
+
   const logger = createLogger('info')
 
   overrideFatal(logger)
@@ -92,6 +94,9 @@ export async function main () {
     case 'resolve':
       command = resolveCommand
       break
+    case 'install':
+      command = installCommand
+      break
     case 'help':
       command = helpCommand
       break
@@ -106,3 +111,5 @@ export async function main () {
 }
 
 export * from './lib/schema.js'
+
+export { resolveServices } from './lib/commands/external.js'

package/lib/commands/build.js

@@ -1,7 +1,88 @@
 import { ensureLoggableError } from '@platformatic/utils'
 import { bold } from 'colorette'
+import { parse } from 'dotenv'
+import { execa } from 'execa'
+import { existsSync } from 'node:fs'
+import { readFile } from 'node:fs/promises'
 import { resolve } from 'node:path'
-import { buildRuntime, findConfigurationFile, overrideFatal, parseArgs } from '../utils.js'
+import { buildRuntime, findConfigurationFile, loadConfigurationFile, overrideFatal, parseArgs } from '../utils.js'
+
+// This function will not perform the command if the .npmrc file contains the 'dry-run' flag - This is useful in tests
+async function executeCommand (root, ...args) {
+  const npmrc = resolve(root, '.npmrc')
+  if (existsSync(npmrc)) {
+    try {
+      const env = parse(await readFile(npmrc, 'utf8'))
+
+      if (env['dry-run'] === 'true') {
+        return
+      }
+      /* c8 ignore next 5 */
+    } catch (error) {
+      // No-op
+    }
+  }
+
+  /* c8 ignore next */
+  return execa(...args)
+}
+
+export async function installDependencies (logger, root, services, production, packageManager) {
+  if (typeof services === 'string') {
+    const config = await loadConfigurationFile(logger, services)
+    services = config.services
+  }
+
+  /* c8 ignore next 8 */
+  if (!packageManager) {
+    if (existsSync(resolve(root, 'pnpm-lock.yaml'))) {
+      packageManager = 'pnpm'
+    } else {
+      packageManager = 'npm'
+    }
+  }
+
+  const args = ['install']
+
+  if (production) {
+    switch (packageManager) {
+      case 'pnpm':
+        args.push('--prod')
+        break
+      case 'npm':
+        args.push('--omit=dev')
+        break
+    }
+  }
+
+  // Install dependencies of the application
+  try {
+    logger.info(
+      `Installing ${production ? 'production ' : ''}dependencies for the application using ${packageManager} ...`
+    )
+
+    await executeCommand(root, packageManager, args, { cwd: root, stdio: 'inherit' })
+    /* c8 ignore next 3 */
+  } catch (error) {
+    logger.fatal({ error: ensureLoggableError(error) }, 'Unable to install dependencies of the application.')
+  }
+
+  for (const service of services) {
+    try {
+      logger.info(
+        `Installing ${production ? 'production ' : ''}dependencies for the service ${bold(service.id)} using ${packageManager} ...`
+      )
+
+      await executeCommand(root, packageManager, args, { cwd: resolve(root, service.path), stdio: 'inherit' })
+      /* c8 ignore next 6 */
+    } catch (error) {
+      logger.fatal(
+        { error: ensureLoggableError(error) },
+        `Unable to install dependencies of the service ${bold(service.id)}.`
+      )
+    }
+  }
+}
 
 export async function buildCommand (logger, args) {
   const { positionals } = parseArgs(args, {}, false)
@@ -40,6 +121,34 @@ export async function buildCommand (logger, args) {
   await runtime.close(false, true)
 }
 
+export async function installCommand (logger, args) {
+  const {
+    values: { production, 'package-manager': packageManager },
+    positionals
+  } = parseArgs(
+    args,
+    {
+      production: {
+        type: 'boolean',
+        short: 'p',
+        default: false
+      },
+      'package-manager': {
+        type: 'string',
+        short: 'P'
+      }
+    },
+    false
+  )
+
+  /* c8 ignore next */
+  const root = resolve(process.cwd(), positionals[0] ?? '')
+  const configurationFile = await findConfigurationFile(logger, root)
+
+  await installDependencies(logger, root, configurationFile, production, packageManager)
+  logger.done('All services have been resolved.')
+}
+
 export const help = {
   build: {
     usage: 'build [root]',
@@ -50,5 +159,25 @@ export const help = {
         description: 'The directory containing the application (the default is the current directory)'
       }
     ]
+  },
+  install: {
+    usage: 'install [root]',
+    description: 'Install all dependencies of an application and its services',
+    args: [
+      {
+        name: 'root',
+        description: 'The directory containing the application (the default is the current directory)'
+      }
+    ],
+    options: [
+      {
+        usage: '-p --production',
+        description: 'Only install production dependencies'
+      },
+      {
+        usage: '-P, --package-manager <executable>',
+        description: 'Use an alternative package manager (the default is to autodetect it)'
+      }
+    ]
   }
 }

package/lib/commands/external.js

@@ -1,56 +1,26 @@
 import { configCandidates } from '@platformatic/basic'
-import { Store } from '@platformatic/config'
-import { platformaticRuntime } from '@platformatic/runtime'
 import { ensureLoggableError } from '@platformatic/utils'
 import { bold } from 'colorette'
+import { parse } from 'dotenv'
 import { execa } from 'execa'
-import { existsSync, } from 'node:fs'
-import { readdir, readFile, stat, writeFile } from 'node:fs/promises'
-import { basename, dirname, isAbsolute, join, relative, resolve, sep } from 'node:path'
+import { existsSync } from 'node:fs'
+import { readFile, writeFile } from 'node:fs/promises'
+import { basename, dirname, isAbsolute, join, relative, resolve } from 'node:path'
 import { defaultServiceJson } from '../defaults.js'
 import { version } from '../schema.js'
-import { findConfigurationFile, overrideFatal, parseArgs } from '../utils.js'
+import {
+  findConfigurationFile,
+  loadConfigurationFile,
+  loadRawConfigurationFile,
+  overrideFatal,
+  parseArgs,
+  saveConfigurationFile,
+  serviceToEnvVariable
+} from '../utils.js'
+import { installDependencies } from './build.js'
 
 const originCandidates = ['origin', 'upstream']
 
-export async function checkEmptyDirectory (logger, path, relativePath) {
-  if (existsSync(path)) {
-    const statObject = await stat(path)
-
-    if (!statObject.isDirectory()) {
-      logger.fatal(`Path ${bold(relativePath)} exists but it is not a directory.`)
-    }
-
-    const entries = await readdir(path)
-
-    if (entries.filter(e => !e.startsWith('.')).length) {
-      logger.fatal(`Directory ${bold(relativePath)} is not empty.`)
-    }
-  }
-}
-
-async function parseConfiguration (logger, configurationFile) {
-  const store = new Store({
-    cwd: process.cwd(),
-    logger
-  })
-  store.add(platformaticRuntime)
-
-  const { configManager } = await store.loadConfig({
-    config: configurationFile,
-    overrides: {
-      /* c8 ignore next 3 */
-      onMissingEnv (key) {
-        return ''
-      }
-    }
-  })
-
-  await configManager.parse()
-
-  return configManager.current
-}
-
 async function parseLocalFolder (path) {
   // Read the package.json, if any
   const packageJsonPath = resolve(path, 'package.json')
@@ -103,54 +73,36 @@ async function findExistingConfiguration (root, path) {
   }
 }
 
-async function addService (configurationFile, id, path, url) {
-  const config = JSON.parse(await readFile(configurationFile, 'utf-8'))
-  const root = dirname(configurationFile)
+export async function appendEnvVariable (envFile, key, value) {
+  let contents = ''
 
-  let autoloadPath = config.autoload?.path
+  if (existsSync(envFile)) {
+    contents = await readFile(envFile, 'utf-8')
 
-  if (autoloadPath) {
-    autoloadPath = join(root, autoloadPath)
-    if (path.startsWith(autoloadPath)) {
-      return
+    if (contents.length && !contents.endsWith('\n')) {
+      contents += '\n'
     }
   }
 
-  /* c8 ignore next */
-  config.web ??= []
-  config.web.push({ id, path, url })
+  contents += `${key}=${value}\n`
 
-  await writeFile(configurationFile, JSON.stringify(config, null, 2), 'utf-8')
+  return writeFile(envFile, contents, 'utf-8')
 }
 
 async function fixConfiguration (logger, root) {
   const configurationFile = await findConfigurationFile(logger, root)
-  const config = JSON.parse(await readFile(configurationFile, 'utf-8'))
-
-  // Load all services in the autoload and the one manually specified
-  const services = []
-  const autoLoadPath = config.autoload?.path
-  if (autoLoadPath) {
-    for (const path of await readdir(resolve(root, autoLoadPath))) {
-      services.push(join(autoLoadPath, path))
-    }
-  }
-
-  /* c8 ignore next */
-  for (const service of config.services ?? []) {
-    services.push(service.path)
-  }
+  const config = await loadConfigurationFile(logger, configurationFile)
 
   // For each service, if there is no watt.json, create one and fix package dependencies
-  for (const service of services) {
-    const wattConfiguration = await findExistingConfiguration(root, service)
+  for (const { path } of config.services) {
+    const wattConfiguration = await findExistingConfiguration(root, path)
 
     /* c8 ignore next 3 */
     if (wattConfiguration) {
       continue
     }
 
-    const { id, packageJson, stackable } = await parseLocalFolder(resolve(root, service))
+    const { id, packageJson, stackable } = await parseLocalFolder(resolve(root, path))
 
     packageJson.dependencies ??= {}
     packageJson.dependencies[stackable] = `^${version}`
@@ -161,28 +113,102 @@ async function fixConfiguration (logger, root) {
     }
 
     logger.info(`Detected stackable ${bold(stackable)} for service ${bold(id)}, adding to the service dependencies.`)
-    await writeFile(resolve(root, service, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8')
-    await writeFile(resolve(root, service, 'watt.json'), JSON.stringify(wattJson, null, 2), 'utf-8')
+
+    await saveConfigurationFile(logger, resolve(path, 'package.json'), packageJson)
+    await saveConfigurationFile(logger, resolve(path, 'watt.json'), wattJson)
   }
 }
 
-async function importLocal (logger, root, configurationFile, path) {
-  const { id, url, packageJson, stackable } = await parseLocalFolder(path)
+async function importService (logger, configurationFile, id, path, url) {
+  const config = await loadConfigurationFile(logger, configurationFile)
+  const rawConfig = await loadRawConfigurationFile(logger, configurationFile)
+  const root = dirname(configurationFile)
+  const envFile = resolve(root, '.env')
+  const envSampleFile = resolve(root, '.env.sample')
+  const envVariable = serviceToEnvVariable(id)
+
+  let useEnv = true
+
+  // If there is a locale path
+  if (path) {
+    let autoloadPath = config.autoload?.path
+
+    // If we already autoload this path, there is nothing to do
+    if (autoloadPath) {
+      autoloadPath = resolve(root, autoloadPath)
+      if (path.startsWith(autoloadPath)) {
+        logger.warn('The path is already autoloaded as a service.')
+        return
+      }
+    }
 
-  // Modify the configuration
-  const config = JSON.parse(await readFile(configurationFile, 'utf-8'))
-  let isAutoloaded = false
-  const autoLoadPath = config.autoload?.path
-  if (autoLoadPath) {
-    const relativePath = relative(root, path)
+    // If the path is within the application repository
+    if (path.startsWith(root)) {
+      // If the path is already defined as a service, there is nothing to do
+      if (config.services.some(s => s.path === path)) {
+        logger.warn('The path is already defined as a service.')
+        return
+      }
+
+      // Do not use env variables
+      useEnv = false
+    }
 
-    isAutoloaded = relativePath.startsWith(`${autoLoadPath}${sep}`)
+    if (!url) {
+      logger.warn(`The service ${bold(id)} does not define a Git repository.`)
+    }
   }
 
-  if (!isAutoloaded) {
-    await addService(configurationFile, id, path, url)
+  // Make sure the service is not already defined
+  if (config.serviceMap.has(id)) {
+    logger.fatal(`There is already a service ${bold(id)} defined, please choose a different service ID.`)
   }
 
+  /* c8 ignore next */
+  rawConfig.web ??= []
+
+  if (useEnv) {
+    rawConfig.web.push({ id, path: `{${envVariable}}`, url })
+
+    // Make sure the environment variable is not already defined
+    if (existsSync(envFile)) {
+      const env = parse(await readFile(envFile, 'utf-8'))
+
+      if (env[envVariable]) {
+        logger.fatal(
+          `There is already an environment variable ${bold(envVariable)} defined, please choose a different service ID.`
+        )
+      }
+    }
+
+    // Copy the .env file to .env.sample if it does not exist
+    if (!existsSync(envSampleFile)) {
+      await writeFile(envSampleFile, '', 'utf-8')
+    }
+
+    await appendEnvVariable(envFile, envVariable, path ?? '')
+    await appendEnvVariable(envSampleFile, envVariable, '')
+  } else {
+    rawConfig.web.push({ id, path: relative(root, path) })
+  }
+
+  await saveConfigurationFile(logger, configurationFile, rawConfig)
+}
+
+async function importURL (logger, _, configurationFile, rawUrl, id, http) {
+  let url = rawUrl
+  if (rawUrl.match(/^[a-z0-9-]+\/[a-z0-9-]+$/i)) {
+    url = http ? `https://github.com/${rawUrl}.git` : `git@github.com:${rawUrl}.git`
+  }
+
+  await importService(logger, configurationFile, id ?? basename(rawUrl, '.git'), null, url)
+}
+
+async function importLocal (logger, root, configurationFile, path, overridenId) {
+  const { id, url, packageJson, stackable } = await parseLocalFolder(path)
+
+  await importService(logger, configurationFile, overridenId ?? id, path, url)
+
   // Check if there is any configuration file we recognize. If so, don't do anything
   const wattConfiguration = await findExistingConfiguration(root, path)
   if (wattConfiguration) {
@@ -204,34 +230,126 @@ async function importLocal (logger, root, configurationFile, path) {
   }
 
   logger.info(`Detected stackable ${bold(stackable)} for service ${bold(id)}, adding to the service dependencies.`)
-  await writeFile(resolve(path, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8')
-  await writeFile(resolve(path, 'watt.json'), JSON.stringify(wattJson, null, 2), 'utf-8')
+
+  await saveConfigurationFile(logger, resolve(path, 'package.json'), packageJson)
+  await saveConfigurationFile(logger, resolve(path, 'watt.json'), wattJson)
 }
 
-async function importURL (logger, root, configurationFile, values, rawUrl) {
-  let url = rawUrl
-  if (rawUrl.match(/^[a-z0-9-]+\/[a-z0-9-]+$/i)) {
-    url = values.http ? `https://github.com/${rawUrl}.git` : `git@github.com:${rawUrl}.git`
+export async function resolveServices (
+  logger,
+  root,
+  configurationFile,
+  username,
+  password,
+  skipDependencies,
+  packageManager
+) {
+  const config = await loadConfigurationFile(logger, configurationFile)
+
+  /* c8 ignore next 8 */
+  if (!packageManager) {
+    if (existsSync(resolve(root, 'pnpm-lock.yaml'))) {
+      packageManager = 'pnpm'
+    } else {
+      packageManager = 'npm'
+    }
   }
 
-  const service = values.id ?? basename(rawUrl, '.git')
-  const path = values.path ?? `web/${service}`
+  // 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)
+  const resolvableServices = config.services.filter(service => {
+    if (!service.url) {
+      return false
+    }
+
+    if (service.path && existsSync(service.path)) {
+      logger.warn(`Skipping service ${bold(service.id)} as the path already exists.`)
+      return false
+    }
+
+    return true
+  })
+
+  // Iterate the services a first time to verify the environment files configuration and which services must be resolved
+  const toResolve = []
+
+  // Simply use service.path here
+  for (const service of resolvableServices) {
+    if (!service.path) {
+      service.path = resolve(root, `${config.resolvedServicesBasePath}/${service.id}`)
+    }
+
+    const directory = resolve(root, service.path)
+
+    // If the directory already exists, it's either external or already resolved, nothing to do in both cases
+    if (!existsSync(directory)) {
+      if (!directory.startsWith(root)) {
+        logger.warn(
+          `Skipping service ${bold(service.id)} as the non existent directory ${bold(service.path)} is outside the project directory.`
+        )
+      } else {
+        // This repository must be resolved
+        toResolve.push(service)
+      }
+    } else {
+      logger.warn(
+        `Skipping service ${bold(service.id)} as the generated path ${bold(join(config.resolvedServicesBasePath, service.id))} already exists.`
+      )
+    }
+  }
 
-  await addService(configurationFile, service, path, url)
+  // Resolve the services
+  for (const service of toResolve) {
+    const childLogger = logger.child({ name: service.id })
+    overrideFatal(childLogger)
+
+    try {
+      const absolutePath = service.path
+      const relativePath = relative(root, absolutePath)
+
+      // Clone and install dependencies
+      childLogger.info(`Resolving service ${bold(service.id)} ...`)
+
+      let url = service.url
+      if (url.startsWith('http') && username && password) {
+        const parsed = new URL(url)
+        parsed.username ||= username
+        parsed.password ||= password
+        url = parsed.toString()
+      }
+
+      if (username) {
+        childLogger.info(`Cloning ${bold(service.url)} as user ${bold(username)} into ${bold(relativePath)} ...`)
+      } else {
+        childLogger.info(`Cloning ${bold(service.url)} into ${bold(relativePath)} ...`)
+      }
+
+      await execa('git', ['clone', url, absolutePath])
+    } catch (error) {
+      childLogger.fatal(
+        { error: ensureLoggableError(error) },
+        `Unable to clone repository of the service ${bold(service.id)}`
+      )
+    }
+  }
+
+  // Install dependencies
+  if (!skipDependencies) {
+    await installDependencies(logger, root, toResolve, false, packageManager)
+  }
 }
 
 export async function importCommand (logger, args) {
-  const { values, positionals } = parseArgs(
+  const {
+    values: { id, http },
+    positionals
+  } = parseArgs(
     args,
     {
       id: {
         type: 'string',
         short: 'i'
       },
-      path: {
-        type: 'string',
-        short: 'p'
-      },
       http: {
         type: 'boolean',
         short: 'h'
@@ -271,15 +389,15 @@ export async function importCommand (logger, args) {
   })
 
   if (local) {
-    return importLocal(logger, root, configurationFile, local)
+    return importLocal(logger, root, configurationFile, local, id)
   }
 
-  return importURL(logger, root, configurationFile, values, rawUrl)
+  return importURL(logger, root, configurationFile, rawUrl, id, http)
 }
 
 export async function resolveCommand (logger, args) {
   const {
-    values: { username, password, 'skip-dependencies': skipDependencies },
+    values: { username, password, 'skip-dependencies': skipDependencies, 'package-manager': packageManager },
     positionals
   } = parseArgs(
     args,
@@ -298,6 +416,10 @@ export async function resolveCommand (logger, args) {
         type: 'boolean',
         short: 's',
         default: false
+      },
+      'package-manager': {
+        type: 'string',
+        short: 'p'
       }
     },
     false
@@ -305,56 +427,9 @@ export async function resolveCommand (logger, args) {
 
   /* c8 ignore next */
   const root = resolve(process.cwd(), positionals[0] ?? '')
-
   const configurationFile = await findConfigurationFile(logger, root)
-  const config = await parseConfiguration(logger, configurationFile)
-
-  for (const service of config.services) {
-    let operation
-    const childLogger = logger.child({ name: service.id })
-    overrideFatal(childLogger)
-
-    try {
-      if (!service.url) {
-        continue
-      }
-
-      childLogger.info(`Resolving service ${bold(service.id)} ...`)
-
-      const relativePath = relative(root, service.path)
-
-      // Check that the target directory is empty, otherwise cloning will likely fail
-      await checkEmptyDirectory(childLogger, service.path, relativePath)
-
-      operation = 'clone repository'
-
-      let url = service.url
-
-      if (url.startsWith('http') && username && password) {
-        const parsed = new URL(url)
-        parsed.username ||= username
-        parsed.password ||= password
-        url = parsed.toString()
-      }
-
-      if (username) {
-        childLogger.info(`Cloning ${bold(service.url)} as user ${bold(username)} into ${bold(relativePath)} ...`)
-      } else {
-        childLogger.info(`Cloning ${bold(service.url)} into ${bold(relativePath)} ...`)
-      }
-
-      await execa('git', ['clone', url, service.path])
-
-      if (!skipDependencies) {
-        operation = 'installing dependencies'
-        childLogger.info('Installing dependencies ...')
-        await execa('npm', ['i'], { cwd: service.path })
-      }
-    } catch (error) {
-      childLogger.fatal({ error: ensureLoggableError(error) }, `Unable to ${operation} of service ${bold(service.id)}`)
-    }
-  }
 
+  await resolveServices(logger, root, configurationFile, username, password, skipDependencies, packageManager)
   logger.done('All services have been resolved.')
 }
 
@@ -377,10 +452,6 @@ export const help = {
         usage: '-i, --id <value>',
         description: 'The id of the service (the default is the basename of the URL)'
       },
-      {
-        usage: '-p, --path <value>',
-        description: 'The path where to import the service (the default is the service id)'
-      },
       {
         usage: '-h, --http',
         description: 'Use HTTP URL when expanding GitHub repositories'
@@ -408,6 +479,10 @@ export const help = {
       {
         usage: '-s, --skip-dependencies',
         description: 'Do not install services dependencies'
+      },
+      {
+        usage: 'P, --package-manager <executable>',
+        description: 'Use an alternative package manager (the default is to autodetect it)'
       }
     ],
     footer: `

package/lib/commands/init.js

@@ -1,13 +1,13 @@
 import { ConfigManager } from '@platformatic/config'
 import { ensureLoggableError } from '@platformatic/utils'
 import { bold } from 'colorette'
-import { existsSync, } from 'node:fs'
+import { existsSync } from 'node:fs'
 import { mkdir, stat, writeFile } from 'node:fs/promises'
 import { basename, resolve } from 'node:path'
 import { defaultConfiguration, defaultPackageJson } from '../defaults.js'
 import { gitignore } from '../gitignore.js'
 import { schema, version } from '../schema.js'
-import { parseArgs, verbose } from '../utils.js'
+import { parseArgs, saveConfigurationFile, verbose } from '../utils.js'
 
 export async function initCommand (logger, args) {
   const {
@@ -57,7 +57,7 @@ export async function initCommand (logger, args) {
 
   // Create the web folder, will implicitly create the root
   try {
-    await mkdir(web, { recursive: true, })
+    await mkdir(web, { recursive: true })
     /* c8 ignore next 6 */
   } catch (error) {
     logger.fatal(
@@ -76,11 +76,11 @@ export async function initCommand (logger, args) {
 
   await configManager.parse()
 
-  await writeFile(
-    configurationFile,
-    JSON.stringify({ $schema: schema.$id, ...configManager.current, entrypoint: positionals[1] ?? undefined }, null, 2),
-    'utf-8'
-  )
+  await saveConfigurationFile(logger, configurationFile, {
+    $schema: schema.$id,
+    ...configManager.current,
+    entrypoint: positionals[1] ?? undefined
+  })
 
   const packageJson = {
     name: basename(root),
@@ -89,13 +89,13 @@ export async function initCommand (logger, args) {
   }
 
   if (packageManager === 'npm') {
-    packageJson.workspaces = ['web/*']
+    packageJson.workspaces = ['web/*', 'external/*']
   } else if (packageManager === 'pnpm') {
-    await writeFile(resolve(root, 'pnpm-workspace.yaml'), "packages:\n  - 'web/*'", 'utf-8')
+    await saveConfigurationFile(logger, resolve(root, 'pnpm-workspace.yaml'), { packages: ['web/*', 'external/*'] })
   }
 
   // Write the package.json file
-  await writeFile(resolve(root, 'package.json'), JSON.stringify(packageJson, null, 2), 'utf-8')
+  await saveConfigurationFile(logger, resolve(root, 'package.json'), packageJson)
 
   // Write the .gitignore file
   await writeFile(resolve(root, '.gitignore'), gitignore, 'utf-8')
@@ -116,6 +116,12 @@ export const help = {
         name: 'entrypoint',
         description: 'The name of the entrypoint service'
       }
+    ],
+    options: [
+      {
+        usage: 'p, --package-manager <executable>',
+        description: 'Use an alternative package manager'
+      }
     ]
   }
 }

package/lib/gitignore.js

@@ -129,4 +129,7 @@ dist
 .yarn/build-state.yml
 .yarn/install-state.gz
 .pnp.*
+
+# Watt resolved folder
+external/
 `

package/lib/utils.js

@@ -1,9 +1,16 @@
-import { ConfigManager, loadConfig as pltConfigLoadConfig, Store } from '@platformatic/config'
+import {
+  ConfigManager,
+  getParser,
+  getStringifier,
+  loadConfig as pltConfigLoadConfig,
+  Store
+} from '@platformatic/config'
 import { platformaticRuntime, buildRuntime as pltBuildRuntime } from '@platformatic/runtime'
 import { bgGreen, black, bold } from 'colorette'
+import { readFile, writeFile } from 'node:fs/promises'
 import { dirname, resolve } from 'node:path'
 import { parseArgs as nodeParseArgs } from 'node:util'
-import pino from 'pino'
+import { pino } from 'pino'
 import pinoPretty from 'pino-pretty'
 
 export let verbose = false
@@ -70,7 +77,12 @@ export function parseArgs (args, options, stopAtFirstPositional = true) {
     tokens: true
   })
 
-  return { values, positionals, unparsed, tokens }
+  return {
+    values,
+    positionals,
+    unparsed,
+    tokens
+  }
 }
 
 export function getMatchingRuntimeArgs (logger, positional) {
@@ -85,12 +97,16 @@ export function getMatchingRuntimeArgs (logger, positional) {
   return args
 }
 
+export function serviceToEnvVariable (service) {
+  return `PLT_SERVICE_${service.toUpperCase().replaceAll(/[^A-Z0-9_]/g, '_')}_PATH`
+}
+
 export async function findConfigurationFile (logger, root) {
   let current = root
   let configurationFile
   while (configurationFile === undefined) {
     // Find a wattpm.json or watt.json file
-    configurationFile = await ConfigManager.findConfigFile(current, ['watt.json', 'wattpm.json', 'platformatic.json'])
+    configurationFile = await ConfigManager.findConfigFile(current, true)
     if (!configurationFile) {
       const newCurrent = dirname(current)
 
@@ -104,7 +120,9 @@ export async function findConfigurationFile (logger, root) {
 
   if (typeof configurationFile !== 'string') {
     logger.fatal(
-      `Cannot find a ${bold('watt.json')}, a ${bold('wattpm.json')} or a ${bold('platformatic.json')} file in ${bold(root)}.`
+      `Cannot find a supported Watt configuration file (like ${bold(
+        'watt.json'
+      )}, a ${bold('wattpm.json')} or a ${bold('platformatic.json')}) in ${bold(root)}.`
     )
   }
 
@@ -112,11 +130,44 @@ export async function findConfigurationFile (logger, root) {
   return resolved
 }
 
+export async function loadConfigurationFile (logger, configurationFile) {
+  const store = new Store({
+    cwd: process.cwd(),
+    logger
+  })
+  store.add(platformaticRuntime)
+
+  const { configManager } = await store.loadConfig({
+    config: configurationFile,
+    overrides: {
+      /* c8 ignore next 3 */
+      onMissingEnv (key) {
+        return ''
+      }
+    }
+  })
+
+  await configManager.parse(true, [])
+  return configManager.current
+}
+
+export async function loadRawConfigurationFile (_, configurationFile) {
+  const parseConfig = getParser(configurationFile)
+
+  return parseConfig(await readFile(configurationFile, 'utf-8'))
+}
+
+export function saveConfigurationFile (logger, configurationFile, config) {
+  const stringifyConfig = getStringifier(configurationFile)
+
+  return writeFile(configurationFile, stringifyConfig(config), 'utf-8')
+}
+
 export async function buildRuntime (logger, configurationFile) {
   const store = new Store()
   store.add(platformaticRuntime)
 
-  const config = await pltConfigLoadConfig({}, ['-c', configurationFile], store, {}, true)
+  const config = await pltConfigLoadConfig({}, ['-c', configurationFile], store, {}, true, logger)
   config.configManager.args = config.args
 
   const runtimeConfig = config.configManager

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "wattpm",
-  "version": "2.19.0",
+  "version": "2.20.0-alpha.2",
   "description": "The Node.js Application Server",
   "main": "index.js",
   "type": "module",
@@ -27,6 +27,7 @@
   "dependencies": {
     "colorette": "^2.0.20",
     "commist": "^3.2.0",
+    "dotenv": "^16.4.5",
     "execa": "^9.4.0",
     "help-me": "^5.0.0",
     "minimist": "^1.2.8",
@@ -34,11 +35,11 @@
     "pino-pretty": "^13.0.0",
     "split2": "^4.2.0",
     "table": "^6.8.2",
-    "@platformatic/config": "2.19.0",
-    "@platformatic/basic": "2.19.0",
-    "@platformatic/control": "2.19.0",
-    "@platformatic/runtime": "2.19.0",
-    "@platformatic/utils": "2.19.0"
+    "@platformatic/basic": "2.20.0-alpha.2",
+    "@platformatic/control": "2.20.0-alpha.2",
+    "@platformatic/config": "2.20.0-alpha.2",
+    "@platformatic/utils": "2.20.0-alpha.2",
+    "@platformatic/runtime": "2.20.0-alpha.2"
   },
   "devDependencies": {
     "borp": "^0.19.0",
@@ -48,7 +49,7 @@
     "neostandard": "^0.11.1",
     "typescript": "^5.5.4",
     "undici": "^7.0.0",
-    "@platformatic/node": "2.19.0"
+    "@platformatic/node": "2.20.0-alpha.2"
   },
   "scripts": {
     "test": "npm run lint && borp --concurrency=1 --timeout=300000",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/wattpm/2.19.0.json",
+  "$id": "https://schemas.platformatic.dev/wattpm/2.20.0-alpha.2.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "type": "object",
   "properties": {
@@ -183,6 +183,7 @@
           },
           "path": {
             "type": "string",
+            "allowEmptyPaths": true,
             "resolvePath": true
           },
           "config": {
@@ -335,6 +336,7 @@
           },
           "path": {
             "type": "string",
+            "allowEmptyPaths": true,
             "resolvePath": true
           },
           "config": {
@@ -1107,6 +1109,10 @@
         }
       ],
       "default": 300000
+    },
+    "resolvedServicesBasePath": {
+      "type": "string",
+      "default": "external"
     }
   },
   "anyOf": [