@platformatic/service 0.23.1 → 0.24.0

package/index.d.ts

@@ -1,16 +1,13 @@
-import { FastifyInstance, InjectOptions, LightMyRequestResponse } from "fastify"
+import { FastifyInstance } from "fastify"
 
 export type pltServiceHandlerBuildServer = {
   app: FastifyInstance
   address: string
   port: number
   restart: () => Promise<void>
-  listen: () => Promise<{
-    address: string
-    port: number
-  }>
-  stop: () => Promise<void>
-  inject: (opts: InjectOptions | string) => Promise<LightMyRequestResponse>
+  listen: FastifyInstance['listen']
+  close: FastifyInstance['close']
+  inject: FastifyInstance['inject']
 }
 
 declare module '@platformatic/service' {

package/index.js

@@ -1,9 +1,5 @@
 'use strict'
 
-const { readFile } = require('fs/promises')
-
-const ConfigManager = require('@platformatic/config')
-const { restartable } = require('@fastify/restartable')
 const { isKeyEnabled } = require('@platformatic/utils')
 
 const compiler = require('./lib/compile')
@@ -18,8 +14,9 @@ const setupHealthCheck = require('./lib/plugins/health-check')
 const loadPlugins = require('./lib/plugins/plugins')
 
 const { schema } = require('./lib/schema')
-const { loadConfig, generateDefaultConfig } = require('./lib/load-config')
+const { loadConfig } = require('./lib/load-config')
 const { addLoggerToTheConfig } = require('./lib/utils')
+const { start, buildServer } = require('./lib/start')
 
 async function platformaticService (app, opts, toLoad = []) {
   const configManager = app.platformatic.configManager
@@ -29,6 +26,17 @@ async function platformaticService (app, opts, toLoad = []) {
     app.register(setupMetrics, config.metrics)
   }
 
+  app.setErrorHandler(async (err, req, reply) => {
+    if (!(err instanceof Error)) {
+      req.log.debug({ err }, 'error encountered within the sandbox, wrapping it')
+      const newError = new Error(err.message)
+      newError.cause = err
+      newError.statusCode = err.statusCode || 500
+      err = newError
+    }
+    throw err
+  })
+
   if (Array.isArray(toLoad)) {
     for (const plugin of toLoad) {
       await app.register(plugin)
@@ -73,123 +81,6 @@ async function platformaticService (app, opts, toLoad = []) {
   }
 }
 
-platformaticService[Symbol.for('skip-override')] = true
-platformaticService.schema = schema
-platformaticService.envWhitelist = ['PORT', 'HOSTNAME']
-
-async function adjustHttpsKeyAndCert (arg) {
-  if (typeof arg === 'string') {
-    return arg
-  }
-
-  if (!Array.isArray(arg)) {
-    // { path: pathToKeyOrCert }
-    return readFile(arg.path)
-  }
-
-  // Array of strings or objects.
-  for (let i = 0; i < arg.length; ++i) {
-    arg[i] = await adjustHttpsKeyAndCert(arg[i])
-  }
-
-  return arg
-}
-
-function defaultConfig (app, source) {
-  const res = {
-    source,
-    ...generateDefaultConfig(),
-    allowToWatch: ['.env', ...(app?.allowToWatch || [])],
-    envWhitelist: ['PORT', ...(app?.envWhitelist || [])]
-  }
-
-  if (app.schema) {
-    res.schema = app.schema
-  }
-
-  return res
-}
-
-async function buildServer (options, app) {
-  app = app || platformaticService
-
-  let configManager = options.configManager
-  if (!configManager) {
-    // instantiate a new config manager from current options
-    configManager = new ConfigManager(defaultConfig(app, options))
-    await configManager.parseAndValidate()
-  }
-
-  // options is a path
-  if (typeof options === 'string') {
-    options = configManager.current
-  }
-
-  let url = null
-
-  async function createRestartable (fastify) {
-    const config = configManager.current
-    const root = fastify(config.server)
-
-    root.decorate('platformatic', { configManager, config })
-    root.register(app)
-
-    root.decorate('url', {
-      getter () {
-        return url
-      }
-    })
-
-    if (root.restarted) {
-      root.log.info('restarted')
-    }
-
-    return root
-  }
-
-  const { port, hostname, ...serverOptions } = options.server
-
-  if (serverOptions.https) {
-    serverOptions.https.key = await adjustHttpsKeyAndCert(serverOptions.https.key)
-    serverOptions.https.cert = await adjustHttpsKeyAndCert(serverOptions.https.cert)
-  }
-
-  const handler = await restartable(createRestartable)
-
-  configManager.on('update', async (newConfig) => {
-    handler.log.debug('config changed')
-    handler.log.trace({ newConfig }, 'new config')
-
-    if (newConfig.watch === false) {
-      /* c8 ignore next 4 */
-      if (handler.tsCompilerWatcher) {
-        handler.tsCompilerWatcher.kill('SIGTERM')
-        handler.log.debug('stop watching typescript files')
-      }
-
-      if (handler.fileWatcher) {
-        await handler.fileWatcher.stopWatching()
-        handler.log.debug('stop watching files')
-      }
-    }
-
-    await safeRestart(handler)
-    /* c8 ignore next 1 */
-  })
-
-  configManager.on('error', function (err) {
-    /* c8 ignore next 1 */
-    handler.log.error({ err }, 'error reloading the configuration')
-  })
-
-  handler.decorate('start', async () => {
-    url = await handler.listen({ host: hostname, port })
-    return url
-  })
-
-  return handler
-}
-
 async function onFilesUpdated (app) {
   // Reload the config as well, otherwise we will have problems
   // in case the files watcher triggers the config watcher too
@@ -209,32 +100,29 @@ async function onFilesUpdated (app) {
   }
 }
 
-async function safeRestart (app) {
-  try {
-    await app.restart()
-    /* c8 ignore next 8 */
-  } catch (err) {
-    app.log.error({
-      err: {
-        message: err.message,
-        stack: err.stack
-      }
-    }, 'failed to reload server')
+platformaticService[Symbol.for('skip-override')] = true
+platformaticService.schema = schema
+platformaticService.configType = 'service'
+platformaticService.configManagerConfig = {
+  schema,
+  envWhitelist: ['PORT', 'HOSTNAME'],
+  allowToWatch: ['.env'],
+  schemaOptions: {
+    useDefaults: true,
+    coerceTypes: true,
+    allErrors: true,
+    strict: false
   }
 }
 
-// This is for @platformatic/db to use
-/* c8 ignore next 4 */
-async function buildStart (loadConfig, buildServer, configManagerConfig) {
-  const { buildStart } = await import('./lib/start.mjs')
-  return buildStart(loadConfig, buildServer, configManagerConfig)
+function _buildServer (options, app) {
+  return buildServer(options, app || platformaticService)
 }
 
-module.exports.buildServer = buildServer
+module.exports.buildServer = _buildServer
 module.exports.schema = require('./lib/schema')
 module.exports.platformaticService = platformaticService
 module.exports.loadConfig = loadConfig
 module.exports.addLoggerToTheConfig = addLoggerToTheConfig
-module.exports.generateConfigManagerConfig = generateDefaultConfig
 module.exports.tsCompiler = compiler
-module.exports.buildStart = buildStart
+module.exports.start = start

package/index.test-d.ts

@@ -1,8 +1,5 @@
 import { expectError, expectType } from 'tsd';
-import {
-  FastifyInstance,
-  LightMyRequestResponse,
-} from 'fastify';
+import { FastifyInstance } from 'fastify';
 import { pltServiceHandlerBuildServer } from '.';
 
 const server: pltServiceHandlerBuildServer = {
@@ -10,9 +7,9 @@ const server: pltServiceHandlerBuildServer = {
   address: 'localhost',
   port: 3000,
   restart: async () => {},
-  listen: async () => ({ address: 'localhost', port: 3000 }),
-  stop: async () => {},
-  inject: async () => ({} as LightMyRequestResponse),
+  listen: async () => '',
+  close: (async () => undefined) as unknown as FastifyInstance['close'],
+  inject: (async () => undefined) as unknown as FastifyInstance['inject']
 };
 
 expectType<pltServiceHandlerBuildServer>(server);

package/lib/compile.js

@@ -102,11 +102,13 @@ async function compileWatch (cwd, config) {
   return { child }
 }
 
-function buildCompileCmd (_loadConfig) {
+function buildCompileCmd (app) {
   return async function compileCmd (_args) {
     let fullPath = null
     try {
-      const { configManager } = await _loadConfig({}, _args)
+      const { configManager } = await loadConfig({}, _args, app, {
+        watch: false
+      })
       await configManager.parseAndValidate()
       fullPath = dirname(configManager.fullPath)
       /* c8 ignore next 4 */
@@ -121,9 +123,6 @@ function buildCompileCmd (_loadConfig) {
   }
 }
 
-const compileCmd = buildCompileCmd(loadConfig)
-
 module.exports.compile = compile
 module.exports.compileWatch = compileWatch
 module.exports.buildCompileCmd = buildCompileCmd
-module.exports.compileCmd = compileCmd

package/lib/load-config.js

@@ -4,32 +4,19 @@ const parseArgs = require('minimist')
 const { access } = require('fs/promises')
 const ConfigManager = require('@platformatic/config')
 const deepmerge = require('@fastify/deepmerge')
-const { schema } = require('./schema.js')
-
-function generateDefaultConfig () {
-  return {
-    schema,
-    schemaOptions: {
-      useDefaults: true,
-      coerceTypes: true,
-      allErrors: true,
-      strict: false
-    }
-  }
-}
 
 // Unfortunately c8 does not see those on Windows
 /* c8 ignore next 70 */
-async function loadConfig (minimistConfig, _args, defaultConfig, configType = 'service') {
-  if (defaultConfig === undefined) {
-    defaultConfig = generateDefaultConfig()
-  } else if (defaultConfig?.mergeDefaults) {
-    defaultConfig = { ...generateDefaultConfig(), ...defaultConfig }
+async function loadConfig (minimistConfig, _args, app, overrides = {}) {
+  const configManagerConfig = {
+    ...app.configManagerConfig,
+    ...overrides
   }
 
+  const configType = app.configType
+
   const args = parseArgs(_args, deepmerge({ all: true })({
     string: ['allow-env'],
-    boolean: ['hotReload'],
     default: {
       allowEnv: '', // The default is set in ConfigManager
       hotReload: true
@@ -37,8 +24,7 @@ async function loadConfig (minimistConfig, _args, defaultConfig, configType = 's
     alias: {
       v: 'version',
       c: 'config',
-      allowEnv: ['allow-env', 'E'],
-      hotReload: ['hot-reload']
+      allowEnv: ['allow-env', 'E']
     }
   }, minimistConfig))
 
@@ -58,10 +44,10 @@ Error: ${err}
     process.exit(1)
   }
 
-  const envWhitelist = args.allowEnv ? args.allowEnv : defaultConfig.envWhitelist
+  const envWhitelist = args.allowEnv ? args.allowEnv : configManagerConfig.envWhitelist
   const configManager = new ConfigManager({
     source: args.config,
-    ...defaultConfig,
+    ...configManagerConfig,
     envWhitelist
   })
 
@@ -85,4 +71,3 @@ function printConfigValidationErrors (configManager) {
 }
 
 module.exports.loadConfig = loadConfig
-module.exports.generateDefaultConfig = generateDefaultConfig

package/lib/plugins/sandbox-wrapper.js

@@ -19,10 +19,17 @@ module.exports = fp(async function (app, opts) {
     } else {
       let loaded = await import(`file://${plugin.path}`)
       /* c8 ignore next 3 */
-      if (loaded.__esModule === true) {
+      if (loaded.__esModule === true || typeof loaded.default === 'function') {
         loaded = loaded.default
       }
+
+      let skipOverride
+      if (plugin.encapsulate === false) {
+        skipOverride = loaded[Symbol.for('skip-override')]
+        loaded[Symbol.for('skip-override')] = true
+      }
       await app.register(loaded, plugin.options)
+      loaded[Symbol.for('skip-override')] = skipOverride
     }
   }
 })

package/lib/start.js

@@ -0,0 +1,176 @@
+'use strict'
+
+const { readFile } = require('fs/promises')
+const close = require('close-with-grace')
+const { loadConfig } = require('./load-config')
+const { addLoggerToTheConfig } = require('./utils.js')
+const ConfigManager = require('@platformatic/config')
+const { restartable } = require('@fastify/restartable')
+
+async function adjustHttpsKeyAndCert (arg) {
+  if (typeof arg === 'string') {
+    return arg
+  }
+
+  if (!Array.isArray(arg)) {
+    // { path: pathToKeyOrCert }
+    return readFile(arg.path)
+  }
+
+  // Array of strings or objects.
+  for (let i = 0; i < arg.length; ++i) {
+    arg[i] = await adjustHttpsKeyAndCert(arg[i])
+  }
+
+  return arg
+}
+
+async function buildServer (options, app) {
+  let configManager = options.configManager
+  if (!configManager) {
+    // instantiate a new config manager from current options
+    configManager = new ConfigManager({ ...app.configManagerConfig, source: options })
+    await configManager.parseAndValidate()
+  }
+
+  // options is a path
+  if (typeof options === 'string') {
+    options = configManager.current
+  }
+
+  let url = null
+
+  async function createRestartable (fastify) {
+    const config = configManager.current
+    const root = fastify(config.server)
+
+    root.decorate('platformatic', { configManager, config })
+    root.register(app)
+
+    root.decorate('url', {
+      getter () {
+        return url
+      }
+    })
+
+    if (root.restarted) {
+      root.log.info('restarted')
+    }
+
+    return root
+  }
+
+  const { port, hostname, ...serverOptions } = options.server
+
+  if (serverOptions.https) {
+    serverOptions.https.key = await adjustHttpsKeyAndCert(serverOptions.https.key)
+    serverOptions.https.cert = await adjustHttpsKeyAndCert(serverOptions.https.cert)
+  }
+
+  const handler = await restartable(createRestartable)
+
+  configManager.on('update', async (newConfig) => {
+    handler.log.debug('config changed')
+    handler.log.trace({ newConfig }, 'new config')
+
+    if (newConfig.watch === false) {
+      /* c8 ignore next 4 */
+      if (handler.tsCompilerWatcher) {
+        handler.tsCompilerWatcher.kill('SIGTERM')
+        handler.log.debug('stop watching typescript files')
+      }
+
+      if (handler.fileWatcher) {
+        await handler.fileWatcher.stopWatching()
+        handler.log.debug('stop watching files')
+      }
+    }
+
+    await safeRestart(handler)
+    /* c8 ignore next 1 */
+  })
+
+  configManager.on('error', function (err) {
+    /* c8 ignore next 1 */
+    handler.log.error({ err }, 'error reloading the configuration')
+  })
+
+  handler.decorate('start', async () => {
+    url = await handler.listen({ host: hostname, port })
+    return url
+  })
+
+  return handler
+}
+
+async function safeRestart (app) {
+  try {
+    await app.restart()
+    /* c8 ignore next 8 */
+  } catch (err) {
+    app.log.error({
+      err: {
+        message: err.message,
+        stack: err.stack
+      }
+    }, 'failed to reload server')
+  }
+}
+
+async function start (appType, _args) {
+  const { configManager } = await loadConfig({}, _args, appType)
+
+  const config = configManager.current
+
+  addLoggerToTheConfig(config)
+
+  const _transformConfig = configManager._transformConfig.bind(configManager)
+  configManager._transformConfig = function () {
+    const config = configManager.current
+    addLoggerToTheConfig(config)
+    return _transformConfig(config)
+  }
+
+  let app = null
+
+  try {
+    // Set the location of the config
+    app = await buildServer({ ...config, configManager }, appType)
+
+    await app.start()
+    // TODO: this log is used in the start command. Should be replaced
+    app.log.info({ url: app.url })
+  } catch (err) {
+    // TODO route this to a logger
+    console.error(err)
+    process.exit(1)
+  }
+
+  // Ignore from CI because SIGUSR2 is not available
+  // on Windows
+  /* c8 ignore next 25 */
+  process.on('SIGUSR2', function () {
+    app.log.info('reloading configuration')
+    safeRestart(app)
+    return false
+  })
+
+  close(async ({ signal, err }) => {
+    // Windows does not support trapping signals
+    if (err) {
+      app.log.error({
+        err: {
+          message: err.message,
+          stack: err.stack
+        }
+      }, 'exiting')
+    } else if (signal) {
+      app.log.info({ signal }, 'received signal')
+    }
+
+    await app.close()
+  })
+}
+
+module.exports.buildServer = buildServer
+module.exports.start = start

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/service",
-  "version": "0.23.1",
+  "version": "0.24.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -55,7 +55,7 @@
     "fastify": "^4.17.0",
     "fastify-metrics": "^10.3.0",
     "fastify-plugin": "^4.5.0",
-    "fastify-sandbox": "^0.11.0",
+    "fastify-sandbox": "^0.12.0",
     "graphql": "^16.6.0",
     "help-me": "^4.2.0",
     "mercurius": "^13.0.0",
@@ -64,9 +64,9 @@
     "pino-pretty": "^10.0.0",
     "rfdc": "^1.3.0",
     "ua-parser-js": "^1.0.35",
-    "@platformatic/client": "0.23.1",
-    "@platformatic/config": "0.23.1",
-    "@platformatic/utils": "0.23.1"
+    "@platformatic/client": "0.24.0",
+    "@platformatic/config": "0.24.0",
+    "@platformatic/utils": "0.24.0"
   },
   "standard": {
     "ignore": [

package/service.mjs

@@ -8,8 +8,9 @@ import { readFile } from 'fs/promises'
 import { join } from 'desm'
 import { generateJsonSchemaConfig } from './lib/gen-schema.js'
 
-import start from './lib/start.mjs'
-import { compileCmd } from './lib/compile.js'
+import { buildCompileCmd } from './lib/compile.js'
+
+import { start, platformaticService } from './index.js'
 
 const help = helpMe({
   dir: join(import.meta.url, 'help'),
@@ -22,8 +23,14 @@ const program = commist({ maxDistance: 2 })
 program.register('help', help.toStdout)
 program.register('help start', help.toStdout.bind(null, ['start']))
 
-program.register('start', start)
-program.register('compile', compileCmd)
+program.register('start', (argv) => {
+  start(platformaticService, argv).catch((err) => {
+    /* c8 ignore next 2 */
+    console.error(err)
+    process.exit(1)
+  })
+})
+program.register('compile', buildCompileCmd(platformaticService))
 program.register('schema config', generateJsonSchemaConfig)
 program.register('schema', help.toStdout.bind(null, ['schema']))
 

package/test/autoload.test.js

@@ -430,3 +430,97 @@ test('nested directories', async ({ teardown, equal, same }) => {
     equal(body, 'I\'m sorry, there was an error processing your request.')
   }
 })
+
+test('disable encapsulation for a single file', async ({ teardown, equal, same }) => {
+  const config = {
+    server: {
+      hostname: '127.0.0.1',
+      port: 0,
+      // Windows CI is slow
+      pluginTimeout: 60 * 1000
+    },
+    service: {
+      openapi: true
+    },
+    plugins: {
+      paths: [{
+        path: join(__dirname, 'fixtures', 'nested-directories', 'plugins', 'decorator.js'),
+        encapsulate: false
+      }, {
+        path: join(__dirname, 'fixtures', 'nested-directories', 'plugins', 'handlers.js'),
+        encapsulate: false
+      }, {
+        path: join(__dirname, 'fixtures', 'nested-directories', 'modules'),
+        encapsulate: false,
+        maxDepth: 1
+      }]
+    }
+  }
+
+  const app = await buildServer(config)
+  teardown(async () => {
+    await app.close()
+  })
+  await app.start()
+
+  {
+    const res = await request(`${app.url}/foo/baz`)
+    equal(res.statusCode, 404, 'status code')
+    const body = await res.body.text()
+    equal(body, 'I\'m sorry, I couldn\'t find what you were looking for.')
+  }
+
+  {
+    const res = await request(`${app.url}/foo`)
+    equal(res.statusCode, 200, 'status code')
+    const body = await res.body.text()
+    equal(body, 'bar')
+  }
+})
+
+test('disable encapsulation for a single file / different order', async ({ teardown, equal, same }) => {
+  const config = {
+    server: {
+      hostname: '127.0.0.1',
+      port: 0,
+      // Windows CI is slow
+      pluginTimeout: 60 * 1000
+    },
+    service: {
+      openapi: true
+    },
+    plugins: {
+      paths: [{
+        path: join(__dirname, 'fixtures', 'nested-directories', 'modules'),
+        encapsulate: false,
+        maxDepth: 1
+      }, {
+        path: join(__dirname, 'fixtures', 'nested-directories', 'plugins', 'decorator.js'),
+        encapsulate: false
+      }, {
+        path: join(__dirname, 'fixtures', 'nested-directories', 'plugins', 'handlers.js'),
+        encapsulate: false
+      }]
+    }
+  }
+
+  const app = await buildServer(config)
+  teardown(async () => {
+    await app.close()
+  })
+  await app.start()
+
+  {
+    const res = await request(`${app.url}/foo/baz`)
+    equal(res.statusCode, 404, 'status code')
+    const body = await res.body.text()
+    equal(body, 'I\'m sorry, I couldn\'t find what you were looking for.')
+  }
+
+  {
+    const res = await request(`${app.url}/foo`)
+    equal(res.statusCode, 200, 'status code')
+    const body = await res.body.text()
+    equal(body, 'bar')
+  }
+})

package/test/cli/compile.test.mjs

@@ -254,7 +254,7 @@ t.test('valid tsconfig file inside an inner folder', async (t) => {
   await cp(testDir, cwd, { recursive: true })
 
   try {
-    await execa('node', [cliPath, 'compile'], { cwd })
+    await execa('node', [cliPath, 'compile'], { cwd, stdio: 'inherit' })
   } catch (err) {
     t.fail('should not catch any error')
   }

package/test/cli/helper.mjs

@@ -21,8 +21,8 @@ tap.teardown(() => {
 
 export const cliPath = join(import.meta.url, '..', '..', 'service.mjs')
 
-export async function start (...args) {
-  const child = execa('node', [cliPath, 'start', ...args])
+export async function start (commandOpts, exacaOpts = {}) {
+  const child = execa('node', [cliPath, 'start', ...commandOpts], exacaOpts)
   child.stderr.pipe(process.stdout)
 
   const output = child.stdout.pipe(split(function (line) {

package/test/cli/start.test.mjs

@@ -5,7 +5,7 @@ import { request } from 'undici'
 import { execa } from 'execa'
 
 test('autostart', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json')])
 
   const res = await request(`${url}`)
   equal(res.statusCode, 200)
@@ -18,7 +18,7 @@ test('autostart', async ({ equal, same, match, teardown }) => {
 })
 
 test('start command', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('start', '-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'platformatic.service.json')])
 
   const res = await request(`${url}`)
   equal(res.statusCode, 200)
@@ -31,8 +31,17 @@ test('start command', async ({ equal, same, match, teardown }) => {
 })
 
 test('allow custom env properties', async ({ equal, same, match, teardown }) => {
-  process.env.A_CUSTOM_PORT = '11111'
-  const { child, url } = await start('start', '-c', join(import.meta.url, '..', 'fixtures', 'custom-port-placeholder.json'), '--allow-env=A_CUSTOM_PORT')
+  const { child, url } = await start(
+    [
+      '-c', join(import.meta.url, '..', 'fixtures', 'custom-port-placeholder.json'),
+      '--allow-env', 'A_CUSTOM_PORT'
+    ],
+    {
+      env: {
+        A_CUSTOM_PORT: '11111'
+      }
+    }
+  )
   equal(url, 'http://127.0.0.1:11111', 'A_CUSTOM_PORT env variable has been used')
   const res = await request(`${url}`)
   equal(res.statusCode, 200)
@@ -43,14 +52,37 @@ test('allow custom env properties', async ({ equal, same, match, teardown }) =>
   delete process.env.A_CUSTOM_PORT
 })
 
+test('use default env variables names', async ({ equal, match }) => {
+  const { child, url } = await start(
+    [
+      '-c', join(import.meta.url, '..', 'fixtures', 'default-env-var-names.json')
+    ],
+    {
+      env: {
+        PORT: '11111',
+        HOSTNAME: '127.0.0.1'
+      }
+    }
+  )
+
+  equal(url, 'http://127.0.0.1:11111', 'default env variable names has been used')
+  const res = await request(`${url}`)
+  equal(res.statusCode, 200)
+  const body = await res.body.json()
+  match(body, {}, 'response')
+
+  child.kill('SIGINT')
+  delete process.env.A_CUSTOM_PORT
+})
+
 test('default logger', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'no-server-logger.json'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'hello', 'no-server-logger.json')])
   match(url, /http:\/\/127.0.0.1:[0-9]+/)
   child.kill('SIGINT')
 })
 
 test('plugin options', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('-c', join(import.meta.url, '..', '..', 'fixtures', 'options', 'platformatic.service.yml'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'options', 'platformatic.service.yml')])
   const res = await request(`${url}`)
   equal(res.statusCode, 200)
   const body = await res.body.json()
@@ -62,7 +94,7 @@ test('plugin options', async ({ equal, same, match, teardown }) => {
 })
 
 test('https embedded pem', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'embedded-pem.json'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'embedded-pem.json')])
 
   match(url, /https:\/\//)
   const res = await request(`${url}`)
@@ -76,7 +108,7 @@ test('https embedded pem', async ({ equal, same, match, teardown }) => {
 })
 
 test('https pem path', async ({ equal, same, match, teardown }) => {
-  const { child, url } = await start('-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'pem-path.json'))
+  const { child, url } = await start(['-c', join(import.meta.url, '..', '..', 'fixtures', 'https', 'pem-path.json')])
 
   match(url, /https:\/\//)
   const res = await request(`${url}`)

package/test/cli/watch.test.mjs

@@ -45,7 +45,7 @@ test('should watch js files by default', async ({ equal, teardown, comment }) =>
     writeFile(pluginFilePath, createLoggingPlugin('v1'))
   ])
 
-  const { child, url } = await start('-c', configFilePath)
+  const { child, url } = await start(['-c', configFilePath])
   teardown(() => child.kill('SIGINT'))
 
   await writeFile(pluginFilePath, createLoggingPlugin('v2', true))
@@ -97,7 +97,7 @@ test('should watch allowed file', async ({ comment, teardown }) => {
     writeFile(pluginFilePath, pluginCode)
   ])
 
-  const { child } = await start('-c', configFilePath)
+  const { child } = await start(['-c', configFilePath])
   teardown(() => child.kill('SIGINT'))
 
   writeFile(jsonFilePath, 'RESTARTED')
@@ -132,7 +132,7 @@ test('should not watch ignored file', async ({ teardown, equal }) => {
     writeFile(pluginFilePath, createLoggingPlugin('v1'))
   ])
 
-  const { child, url } = await start('-c', configFilePath)
+  const { child, url } = await start(['-c', configFilePath])
   teardown(() => child.kill('SIGINT'))
 
   await writeFile(pluginFilePath, createLoggingPlugin('v2', true))
@@ -170,7 +170,7 @@ test('should not loop forever when doing ESM', async ({ comment, fail }) => {
     writeFile(pluginFilePath, 'export default async (app) => {}')
   ])
 
-  const { child } = await start('-c', configFilePath)
+  const { child } = await start(['-c', configFilePath])
 
   await sleep(1000)
 
@@ -239,7 +239,7 @@ test('should watch config file', async ({ comment, teardown }) => {
     writeFile(pluginFilePath, pluginCode)
   ])
 
-  const { child } = await start('-c', configFilePath)
+  const { child } = await start(['-c', configFilePath])
   teardown(() => child.kill('SIGINT'))
 
   // We do not await
@@ -249,49 +249,6 @@ test('should watch config file', async ({ comment, teardown }) => {
   }
 })
 
-test('should not hot reload files with `--hot-reload false`', async ({ teardown, equal }) => {
-  const tmpDir = await mkdtemp(join(os.tmpdir(), 'watch-'))
-  const pluginFilePath = join(tmpDir, 'plugin.js')
-  const configFilePath = join(tmpDir, 'platformatic.service.json')
-
-  const config = {
-    server: {
-      logger: {
-        level: 'info'
-      },
-      hostname: '127.0.0.1',
-      port: 0
-    },
-    plugins: {
-      paths: [pluginFilePath]
-    }
-  }
-
-  await Promise.all([
-    writeFile(configFilePath, JSON.stringify(config)),
-    writeFile(pluginFilePath, createLoggingPlugin('v1'))
-  ])
-
-  const { child, url } = await start('-c', configFilePath, '--hot-reload', 'false')
-  teardown(() => child.kill('SIGINT'))
-
-  {
-    const res = await request(`${url}/version`)
-    const version = await res.body.text()
-    equal(version, 'v1')
-  }
-
-  await writeFile(pluginFilePath, createLoggingPlugin('v2', true))
-
-  await sleep(5000)
-
-  {
-    const res = await request(`${url}/version`)
-    const version = await res.body.text()
-    equal(version, 'v1')
-  }
-})
-
 test('should not fail when updating wrong config', async ({ equal, teardown, comment }) => {
   const tmpDir = await mkdtemp(join(os.tmpdir(), 'watch-'))
   comment(`using ${tmpDir}`)
@@ -309,7 +266,7 @@ test('should not fail when updating wrong config', async ({ equal, teardown, com
     plugins: {
       paths: [pluginFilePath]
     },
-    watch: false
+    watch: true
   }
 
   await Promise.all([
@@ -317,13 +274,13 @@ test('should not fail when updating wrong config', async ({ equal, teardown, com
     writeFile(pluginFilePath, createLoggingPlugin('v1', true))
   ])
 
-  const { child, url } = await start('-c', configFilePath)
+  const { child, url } = await start(['-c', configFilePath])
   teardown(() => child.kill('SIGINT'))
 
   writeFile(configFilePath, 'this is not a valid config')
 
   for await (const log of child.ndj) {
-    if (log.msg === 'error reloading the configuration') break
+    if (log.msg === 'failed to reload server') break
   }
 
   const res = await request(`${url}/version`)

package/test/config.test.js

@@ -3,7 +3,6 @@
 require('./helper')
 const { test } = require('tap')
 const { buildServer } = require('..')
-const { loadConfig } = require('../lib/load-config')
 const { request } = require('undici')
 const { join } = require('path')
 const os = require('os')
@@ -295,30 +294,3 @@ test('config reloads', async ({ teardown, equal, pass, same }) => {
     same(await res.body.text(), 'ciao mondo', 'response')
   }
 })
-
-test('can merge provided config with default config', async ({ plan, same }) => {
-  plan(6)
-  const configFile = join(__dirname, 'fixtures', 'custom-port-placeholder.json')
-  const defaultConfig = {
-    mergeDefaults: true,
-    onMissingEnv (key) {
-      same(key, 'A_CUSTOM_PORT')
-      return '42'
-    }
-  }
-
-  {
-    const config = await loadConfig({}, ['-c', configFile], defaultConfig)
-    same(config.configManager.current.server.port, 42)
-    // This comes from the default config.
-    same(config.configManager.schemaOptions.useDefaults, true)
-  }
-
-  {
-    defaultConfig.mergeDefaults = false
-    const config = await loadConfig({}, ['-c', configFile], defaultConfig)
-    same(config.configManager.current.server.port, 42)
-    // This comes from the default config.
-    same(config.configManager.schemaOptions.useDefaults, undefined)
-  }
-})

package/test/fixtures/default-env-var-names.json

@@ -0,0 +1,7 @@
+{
+  "server": {
+    "hostname": "{HOSTNAME}",
+    "port": "{PORT}",
+    "pluginTimeout": "10"
+  }
+}

package/test/fixtures/nested-directories/modules/inventory/index.js

@@ -24,6 +24,10 @@ async function inventory (fastify, opts) {
       prefix: opts.prefix
     }
   })
+
+  fastify.get('/foo', async function (req) {
+    return req.foo
+  })
 }
 
 export default fp(inventory)

package/test/fixtures/nested-directories/plugins/decorator.js

@@ -0,0 +1,3 @@
+export default async function foo (app) {
+  app.decorateRequest('foo', 'bar')
+}

package/test/fixtures/other-side.js

@@ -0,0 +1,9 @@
+'use strict'
+
+module.exports = async function (app) {
+  app.addHook('onRequest', async () => {
+    throw new TypeError('kaboom')
+  })
+}
+
+module.exports[Symbol.for('skip-override')] = true

package/test/load-plugin.test.js

@@ -31,3 +31,37 @@ test('customize service', async ({ teardown, equal }) => {
   equal(res.statusCode, 200)
   equal(body, 'hello world')
 })
+
+test('catch errors from the other side', async ({ teardown, equal, same }) => {
+  async function myApp (app, opts) {
+    await platformaticService(app, opts, [async function (app) {
+      app.get('/', () => 'hello world')
+    }])
+  }
+
+  const app = await buildServer({
+    server: {
+      hostname: '127.0.0.1',
+      port: 0
+    },
+    plugins: {
+      paths: [{
+        path: require.resolve('./fixtures/other-side.js')
+      }]
+    }
+  }, myApp)
+
+  teardown(async () => {
+    await app.close()
+  })
+  await app.start()
+
+  const res = await (request(app.url))
+  const body = await res.body.json()
+  equal(res.statusCode, 500)
+  same(body, {
+    statusCode: 500,
+    error: 'Internal Server Error',
+    message: 'kaboom'
+  })
+})

package/lib/start.mjs

@@ -1,105 +0,0 @@
-import { buildServer } from '../index.js'
-import close from 'close-with-grace'
-import { loadConfig, generateDefaultConfig } from './load-config.js'
-import { addLoggerToTheConfig } from './utils.js'
-
-// TODO make sure coverage is reported for Windows
-// Currently C8 is not reporting it
-/* c8 ignore start */
-
-function defaultConfig () {
-  const _defaultConfig = generateDefaultConfig()
-  return {
-    watch: true,
-    ..._defaultConfig
-  }
-}
-
-export function buildStart (_loadConfig, _buildServer, _configManagerConfig) {
-  return async function start (_args) {
-    const _defaultConfig = _configManagerConfig ?? defaultConfig()
-    const { configManager, args } = await _loadConfig({}, _args, _defaultConfig)
-
-    const config = configManager.current
-
-    // Disable hot reload from the CLI
-    if (args.hotReload === false && configManager.current.plugins) {
-      configManager.current.plugins.hotReload = false
-    }
-    addLoggerToTheConfig(config)
-
-    const _transformConfig = configManager._transformConfig.bind(configManager)
-    configManager._transformConfig = function () {
-      const config = configManager.current
-      if (args.hotReload === false && config.plugins) {
-        config.plugins.hotReload = false
-      }
-      addLoggerToTheConfig(config)
-      return _transformConfig(config)
-    }
-
-    let app = null
-
-    try {
-      // Set the location of the config
-      app = await _buildServer({ ...config, configManager })
-
-      await app.start()
-      // TODO: this log is used in the start command. Should be replaced
-      app.log.info({ url: app.url })
-    } catch (err) {
-      // TODO route this to a logger
-      console.error(err)
-      process.exit(1)
-    }
-
-    // Ignore from CI because SIGUSR2 is not available
-    // on Windows
-    process.on('SIGUSR2', function () {
-      app.log.info('reloading configuration')
-      safeRestart(app)
-      return false
-    })
-
-    close(async ({ signal, err }) => {
-      // Windows does not support trapping signals
-      if (err) {
-        app.log.error({
-          err: {
-            message: err.message,
-            stack: err.stack
-          }
-        }, 'exiting')
-      } else if (signal) {
-        app.log.info({ signal }, 'received signal')
-      }
-
-      await app.close()
-    })
-  }
-}
-
-const start = buildStart(loadConfig, buildServer)
-
-async function safeRestart (app) {
-  try {
-    await app.restart()
-  } catch (err) {
-    app.log.error({
-      err: {
-        message: err.message,
-        stack: err.stack
-      }
-    }, 'failed to reload server')
-  }
-}
-
-export default function (args) {
-  start(args).catch(exit)
-}
-
-function exit (err) {
-  console.error(err)
-  process.exit(1)
-}
-/* c8 ignore stop */