@platformatic/service 0.21.0 → 0.22.0

package/fixtures/hello/warn-log.service.json

@@ -0,0 +1,19 @@
+{
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "warn",
+      "name": "hello server"
+    }
+  },
+  "plugins": {
+    "paths": ["./plugin.js"],
+    "hotReload": false
+  },
+  "service": {
+    "openapi": true
+  },
+  "metrics": false,
+  "watch": false
+}

package/fixtures/hello-client/platformatic.service.json

@@ -3,7 +3,7 @@
     "hostname": "127.0.0.1",
     "port": 0,
     "logger": {
-      "level": "info",
+      "level": "warn",
       "name": "hello client"
     }
   },

package/fixtures/hello-client-ts/platformatic.service.json

@@ -3,7 +3,7 @@
     "hostname": "127.0.0.1",
     "port": 0,
     "logger": {
-      "level": "info",
+      "level": "warn",
       "name": "hello client ts"
     }
   },

package/index.js

@@ -7,7 +7,7 @@ const { schema } = require('./lib/schema')
 const ConfigManager = require('@platformatic/config')
 const { loadConfig, generateDefaultConfig } = require('./lib/load-config')
 const { addLoggerToTheConfig, getJSPluginPath, isFileAccessible } = require('./lib/utils')
-const { isKeyEnabled, deepmerge } = require('@platformatic/utils')
+const { isKeyEnabled } = require('@platformatic/utils')
 const compiler = require('./lib/compile')
 const { join, dirname, resolve } = require('path')
 const { readFile } = require('fs/promises')
@@ -15,14 +15,6 @@ const wrapperPath = join(__dirname, 'lib', 'sandbox-wrapper.js')
 const setupOpenAPI = require('./lib/openapi.js')
 const setupGraphQL = require('./lib/graphql.js')
 
-function createServerConfig (config) {
-  // convert the config file to a new structure
-  // to make @fastify/restartable happy
-  const serverConfig = Object.assign({ ...config.server }, config)
-  delete serverConfig.server
-  return serverConfig
-}
-
 function originToRegexp (origin) {
   if (typeof origin === 'object') {
     if (origin.regexp) {
@@ -34,67 +26,44 @@ function originToRegexp (origin) {
 }
 
 async function platformaticService (app, opts, toLoad = []) {
-  if (isKeyEnabled('metrics', opts)) {
-    app.register(require('./lib/metrics-plugin'), opts.metrics)
+  const configManager = app.platformatic.configManager
+  const config = configManager.current
+
+  if (isKeyEnabled('metrics', config)) {
+    app.register(require('./lib/metrics-plugin'), config.metrics)
   }
 
   if (Array.isArray(toLoad)) {
     for (const plugin of toLoad) {
-      await app.register(plugin, opts)
+      await app.register(plugin)
     }
   }
 
-  if (!app.hasDecorator('platformatic')) {
-    app.decorate('platformatic', {})
-  }
+  const serviceConfig = app.platformatic.config?.service
 
-  {
-    const fileWatcher = opts.fileWatcher
-    const configManager = opts.configManager
-    /* c8 ignore next 3 */
-    if (fileWatcher !== undefined) {
-      app.platformatic.fileWatcher = fileWatcher
-    }
-    if (configManager !== undefined) {
-      app.platformatic.configManager = configManager
-      app.platformatic.config = configManager.current
-      /* c8 ignore next 3 */
-    } else {
-      throw new Error('configManager is required')
-    }
+  if (serviceConfig?.openapi) {
+    await setupOpenAPI(app, serviceConfig.openapi)
   }
 
-  {
-    const serviceConfig = app.platformatic.config?.service
-
-    // for some unknown reason, c8 is not detecting any of this
-    // despite being covered by test/routes.test.js
-    /* c8 ignore next 3 */
-    if (serviceConfig?.openapi) {
-      await setupOpenAPI(app, app.platformatic.config?.service?.openapi)
-    }
-
-    /* c8 ignore next 3 */
-    if (serviceConfig?.graphql) {
-      await setupGraphQL(app, app.platformatic.config?.service?.graphql)
-    }
+  if (serviceConfig?.graphql) {
+    await setupGraphQL(app, serviceConfig.graphql)
   }
 
-  for (const plugin of (app.platformatic.config.clients || [])) {
+  for (const plugin of (config.clients || [])) {
     app.register(require(plugin.path), {
       url: plugin.url
     })
   }
 
-  if (opts.plugins) {
+  if (config.plugins) {
     // if we don't have a fullPath, let's assume we are in a test and we can use the current working directory
-    const configPath = app.platformatic.configManager.fullPath || join(process.cwd(), 'platformatic.db.json')
+    const configPath = configManager.fullPath || join(process.cwd(), 'platformatic.db.json')
     const tsConfigPath = join(dirname(configPath), 'tsconfig.json')
     /* c8 ignore next 21 */
     if (await isFileAccessible(tsConfigPath)) {
       const tsConfig = JSON.parse(await readFile(tsConfigPath, 'utf8'))
       const outDir = resolve(dirname(tsConfigPath), tsConfig.compilerOptions.outDir)
-      opts.plugins.paths = opts.plugins.paths.map((plugin) => {
+      config.plugins.paths = config.plugins.paths.map((plugin) => {
         if (typeof plugin === 'string') {
           return getJSPluginPath(configPath, plugin, outDir)
         } else {
@@ -105,7 +74,7 @@ async function platformaticService (app, opts, toLoad = []) {
         }
       })
     } else {
-      for (const plugin of opts.plugins.paths) {
+      for (const plugin of config.plugins.paths) {
         const path = typeof plugin === 'string' ? plugin : plugin.path
         if (path.endsWith('.ts')) {
           throw new Error(`Cannot load plugin ${path}, tsconfig.json not found`)
@@ -117,14 +86,15 @@ async function platformaticService (app, opts, toLoad = []) {
     // that's why we ignore the coverage of the `undefined` case, which cannot be covered in cli tests)
     // all individual plugin hot reload settings will be overloaded by global hot reload
     /* c8 ignore next 1 */
-    const hotReload = opts.plugins.hotReload !== false
-    const isWatchEnabled = app.platformatic.config.watch !== false
-    app.log.debug({ plugins: opts.plugins.path }, 'loading plugin')
+    const hotReload = config.plugins.hotReload !== false
+    const isWatchEnabled = config.watch !== false
+
+    app.log.debug({ plugins: config.plugins.paths, hotReload, isWatchEnabled }, 'loading plugins')
 
     if (isWatchEnabled && hotReload) {
       await app.register(sandbox, {
         path: wrapperPath,
-        options: { paths: opts.plugins.paths },
+        options: { paths: config.plugins.paths },
         customizeGlobalThis (_globalThis) {
           // Taken from https://github.com/nodejs/undici/blob/fa9fd9066569b6357acacffb806aa804b688c9d8/lib/global.js#L5
           const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
@@ -136,35 +106,36 @@ async function platformaticService (app, opts, toLoad = []) {
         }
       })
     } else {
-      await app.register(require(wrapperPath), { paths: opts.plugins.paths })
+      await app.register(require(wrapperPath), { paths: config.plugins.paths })
     }
   }
 
   // Enable CORS
-  if (opts.cors) {
-    let origin = opts.cors.origin
+  if (config.server.cors) {
+    let origin = config.server.cors.origin
     if (Array.isArray(origin)) {
       origin = origin.map(originToRegexp)
     } else {
       origin = originToRegexp(origin)
     }
 
-    opts.cors.origin = origin
+    config.server.cors.origin = origin
 
-    app.register(require('@fastify/cors'), opts.cors)
+    app.register(require('@fastify/cors'), config.server.cors)
   }
 
-  if (isKeyEnabled('healthCheck', opts)) {
+  if (isKeyEnabled('healthCheck', config.server)) {
+    const healthCheck = config.server.healthCheck
     app.register(underPressure, {
       exposeStatusRoute: '/status',
-      healthCheckInterval: opts.healthCheck.interval !== undefined ? opts.healthCheck.interval : 5000,
-      ...opts.healthCheck,
-      healthCheck: opts.healthCheck.fn
+      healthCheckInterval: healthCheck.interval !== undefined ? healthCheck.interval : 5000,
+      ...healthCheck,
+      healthCheck: healthCheck.fn
     })
   }
 
   if (!app.hasRoute({ url: '/', method: 'GET' }) && !Array.isArray(toLoad)) {
-    await app.register(require('./lib/root-endpoint'), opts)
+    await app.register(require('./lib/root-endpoint'))
   }
 }
 
@@ -172,37 +143,6 @@ platformaticService[Symbol.for('skip-override')] = true
 platformaticService.schema = schema
 platformaticService.envWhitelist = ['PORT', 'HOSTNAME']
 
-function adjustConfigBeforeMerge (cm) {
-  // This function and adjustConfigAfterMerge() are needed because there are
-  // edge cases that deepmerge() does not handle properly. This code does not
-  // live in the generic config manager because that object is not aware of
-  // these schema dependent details.
-  const stash = new Map()
-
-  // If a pino instance is passed as the logger, it will contain a child()
-  // function that is not enumerable. Non-enumerables are not copied by
-  // deepmerge(), so stash the logger here.
-  /* c8 ignore next 5 */
-  if (typeof cm.server?.logger?.child === 'function' &&
-      !Object.prototype.propertyIsEnumerable.call(cm.server.logger, 'child')) {
-    stash.set('server.logger', cm.server.logger)
-    cm.server.logger = null
-  }
-
-  return stash
-}
-
-function adjustConfigAfterMerge (options, stash) {
-  // Restore any config that needed to be stashed prior to merging.
-  const pinoLogger = stash.get('server.logger')
-
-  /* c8 ignore next 4 */
-  if (pinoLogger) {
-    options.server.logger = pinoLogger
-    options.configManager.current.server.logger = pinoLogger
-  }
-}
-
 async function adjustHttpsKeyAndCert (arg) {
   if (typeof arg === 'string') {
     return arg
@@ -238,30 +178,50 @@ function defaultConfig (app, source) {
 
 async function buildServer (options, app) {
   app = app || platformaticService
+  let cm
 
   if (!options.configManager) {
     // instantiate a new config manager from current options
-    const cm = new ConfigManager(defaultConfig(app, options))
+    cm = new ConfigManager(defaultConfig(app, options))
     await cm.parseAndValidate()
-    const stash = adjustConfigBeforeMerge(cm.current)
-    options = deepmerge({}, options, cm.current)
-    options.configManager = cm
-    adjustConfigAfterMerge(options, stash)
+  } else {
+    cm = options.configManager
   }
 
-  if (options.server.https) {
-    options.server.https.key = await adjustHttpsKeyAndCert(options.server.https.key)
-    options.server.https.cert = await adjustHttpsKeyAndCert(options.server.https.cert)
-    options.server = { ...options.server, ...options.server.https }
-    delete options.server.https
-    options.server.protocol = 'https'
-  } else {
-    options.server.protocol = 'http'
+  // options is a path
+  if (typeof options === 'string') {
+    options = cm.current
+  }
+
+  async function jumpApp (root) {
+    root.decorate('platformatic', {})
+
+    const fileWatcher = options.fileWatcher
+    /* c8 ignore next 3 */
+    if (fileWatcher !== undefined) {
+      root.platformatic.fileWatcher = fileWatcher
+    }
+    root.platformatic.configManager = cm
+    root.platformatic.config = cm.current
+    root.register(app)
+  }
+  jumpApp[Symbol.for('skip-override')] = true
+
+  const serverConfig = {
+    ...(options.server),
+    configManager: cm,
+    app: jumpApp
+  }
+
+  if (serverConfig.https) {
+    serverConfig.key = await adjustHttpsKeyAndCert(options.server.https.key)
+    serverConfig.cert = await adjustHttpsKeyAndCert(options.server.https.cert)
+    delete serverConfig.https
+    serverConfig.protocol = 'https'
+  } else if (options.server) {
+    serverConfig.protocol = 'http'
   }
-  const serverConfig = createServerConfig(options)
 
-  serverConfig.originalConfig = options
-  serverConfig.app = app
   const handler = await start(serverConfig)
 
   Object.defineProperty(handler, 'url', {
@@ -274,42 +234,44 @@ async function buildServer (options, app) {
     }
   })
 
-  const _restart = handler.restart
+  restarter(handler, cm, jumpApp)
 
+  return handler
+}
+
+function restarter (handler, cm, jumpApp) {
   let debounce = null
-  handler.restart = (opts) => {
-    /* c8 ignore next 3 */
+  const _restart = handler.restart
+  handler.restart = restart
+  handler.app.restart = restart
+
+  // This is covered by tests but c8 doesn't see it
+  /* c8 ignore next 30 */
+  async function restart (opts) {
     if (debounce) {
       return debounce
     }
 
-    addLoggerToTheConfig(opts)
-    const configManager = handler.app.platformatic.configManager
-
-    if (!opts) {
-      opts = configManager.current
+    if (opts && !await cm.update(opts)) {
+      const err = new Error('Invalid config')
+      err.validationErrors = cm.validationErrors
+      throw err
     }
 
-    // Ignore because not tested on Windows
-    // TODO: remove the ignore, we shoduld be testing
-    // this on Windows
-    const fileWatcher = handler.app.platformatic.fileWatcher
-    opts.fileWatcher = fileWatcher
-    opts.configManager = configManager
-    opts = createServerConfig(opts)
-    opts.app = app
+    const restartOpts = {
+      ...(cm.current.server),
+      fileWatcher: handler.app.platformatic.fileWatcher,
+      configManager: cm,
+      app: jumpApp
+    }
 
-    debounce = _restart(opts).then(() => {
+    debounce = _restart(restartOpts).then(() => {
       handler.app.log.info('restarted')
     }).finally(() => {
       debounce = null
     })
     return debounce
   }
-
-  handler.app.restart = handler.restart
-
-  return handler
 }
 
 // This is for @platformatic/db to use
@@ -321,10 +283,9 @@ async function buildStart (loadConfig, buildServer) {
 
 module.exports.buildServer = buildServer
 module.exports.schema = require('./lib/schema')
-module.exports.createServerConfig = createServerConfig
 module.exports.platformaticService = platformaticService
-module.exports.addLoggerToTheConfig = addLoggerToTheConfig
 module.exports.loadConfig = loadConfig
+module.exports.addLoggerToTheConfig = addLoggerToTheConfig
 module.exports.generateConfigManagerConfig = generateDefaultConfig
 module.exports.tsCompiler = compiler
 module.exports.buildStart = buildStart

package/lib/compile.js

@@ -28,7 +28,7 @@ async function getTSCExecutablePath (cwd) {
   }
 }
 
-async function setup (cwd) {
+async function setup (cwd, config) {
   const logger = pino(
     pretty({
       translateTime: 'SYS:HH:MM:ss',
@@ -36,6 +36,10 @@ async function setup (cwd) {
     })
   )
 
+  if (config?.server.logger) {
+    logger.level = config.server.logger.level
+  }
+
   const { execa } = await import('execa')
 
   const tscExecutablePath = await getTSCExecutablePath(cwd)
@@ -56,8 +60,8 @@ async function setup (cwd) {
   return { execa, logger, tscExecutablePath }
 }
 
-async function compile (cwd) {
-  const { execa, logger, tscExecutablePath } = await setup(cwd)
+async function compile (cwd, config) {
+  const { execa, logger, tscExecutablePath } = await setup(cwd, config)
   /* c8 ignore next 3 */
   if (!tscExecutablePath) {
     return false
@@ -76,8 +80,8 @@ async function compile (cwd) {
 // This path is tested but C8 does not see it that way given it needs to work
 // through execa.
 /* c8 ignore next 20 */
-async function compileWatch (cwd) {
-  const { execa, logger, tscExecutablePath } = await setup(cwd)
+async function compileWatch (cwd, config) {
+  const { execa, logger, tscExecutablePath } = await setup(cwd, config)
   if (!tscExecutablePath) {
     return false
   }

package/lib/load-config.js

@@ -4,18 +4,8 @@ const parseArgs = require('minimist')
 const { access } = require('fs/promises')
 const ConfigManager = require('@platformatic/config')
 const deepmerge = require('@fastify/deepmerge')
-const { findConfigFile } = require('./utils.js')
 const { schema } = require('./schema.js')
 
-const ourConfigFiles = [
-  'platformatic.service.json',
-  'platformatic.service.json5',
-  'platformatic.service.yaml',
-  'platformatic.service.yml',
-  'platformatic.service.toml',
-  'platformatic.service.tml'
-]
-
 function generateDefaultConfig () {
   return {
     schema,
@@ -30,7 +20,7 @@ function generateDefaultConfig () {
 
 // Unfortunately c8 does not see those on Windows
 /* c8 ignore next 70 */
-async function loadConfig (minimistConfig, _args, defaultConfig, configFileNames = ourConfigFiles) {
+async function loadConfig (minimistConfig, _args, defaultConfig, configType = 'service') {
   defaultConfig ??= generateDefaultConfig()
   const args = parseArgs(_args, deepmerge({ all: true })({
     string: ['allow-env'],
@@ -49,22 +39,25 @@ async function loadConfig (minimistConfig, _args, defaultConfig, configFileNames
 
   try {
     if (!args.config) {
-      args.config = await findConfigFile(process.cwd(), configFileNames)
+      args.config = await ConfigManager.findConfigFile(process.cwd(), configType)
     }
     await access(args.config)
   } catch (err) {
+    const configFiles = ConfigManager.listConfigFiles(configType)
     console.error(`
 Missing config file!
-Be sure to have a config file with one of the following names: ${ourConfigFiles.join('\n')}
+Be sure to have a config file with one of the following names: ${configFiles.join('\n')}
 In alternative run "npm create platformatic@latest" to generate a basic plt service config.
 Error: ${err}
 `)
     process.exit(1)
   }
 
+  const envWhitelist = args.allowEnv ? args.allowEnv : defaultConfig.envWhitelist
   const configManager = new ConfigManager({
     source: args.config,
-    ...defaultConfig
+    ...defaultConfig,
+    envWhitelist
   })
 
   const parsingResult = await configManager.parse()

package/lib/start.mjs

@@ -33,7 +33,7 @@ export function buildStart (_loadConfig, _buildServer) {
       config.plugins?.watch !== false
     ) {
       try {
-        await compileWatch(dirname(configManager.fullPath))
+        await compileWatch(dirname(configManager.fullPath), config)
       } catch (error) {
         // TODO route this to a logger
         console.error(error)
@@ -190,6 +190,7 @@ async function onFilesUpdated (server, hotReload) {
     if (hotReload === false && configManager.current.plugins) {
       configManager.current.plugins.hotReload = false
     }
+    addLoggerToTheConfig(configManager.current)
     await server.restart(configManager.current)
   } catch (err) {
     // TODO: test this

package/lib/utils.js

@@ -3,12 +3,6 @@
 const { access } = require('fs/promises')
 const { resolve, join, relative, dirname, basename } = require('path')
 
-async function findConfigFile (directory, configFileNames) {
-  const configFilesAccessibility = await Promise.all(configFileNames.map((fileName) => isFileAccessible(fileName, directory)))
-  const accessibleConfigFilename = configFileNames.find((value, index) => configFilesAccessibility[index])
-  return accessibleConfigFilename
-}
-
 async function isFileAccessible (filename, directory) {
   try {
     const filePath = directory ? resolve(directory, filename) : filename
@@ -21,8 +15,6 @@ async function isFileAccessible (filename, directory) {
 
 /* c8 ignore start */
 function addLoggerToTheConfig (config) {
-  if (config === undefined || config.server === undefined) return
-
   // Set the logger if not present
   let logger = config.server.logger
   if (!logger) {
@@ -66,7 +58,6 @@ function getJSPluginPath (configPath, tsPluginPath, compileDir) {
 }
 
 module.exports = {
-  findConfigFile,
   isFileAccessible,
   getJSPluginPath,
   addLoggerToTheConfig

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/service",
-  "version": "0.21.0",
+  "version": "0.22.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -22,50 +22,50 @@
     "c8": "^7.13.0",
     "self-cert": "^2.0.0",
     "snazzy": "^9.0.0",
-    "split2": "^4.1.0",
+    "split2": "^4.2.0",
     "standard": "^17.0.0",
     "strip-ansi": "^7.0.1",
     "tap": "^16.3.4",
-    "tsd": "^0.28.0",
-    "typescript": "^5.0.0",
-    "undici": "^5.20.0",
-    "vscode-json-languageservice": "^5.3.0",
+    "tsd": "^0.28.1",
+    "typescript": "^5.0.4",
+    "undici": "^5.22.0",
+    "vscode-json-languageservice": "^5.3.4",
     "why-is-node-running": "^2.2.2",
-    "yaml": "^2.2.1"
+    "yaml": "^2.2.2"
   },
   "dependencies": {
     "@fastify/accepts": "^4.1.0",
     "@fastify/autoload": "^5.7.1",
     "@fastify/basic-auth": "^5.0.0",
-    "@fastify/cors": "^8.2.0",
+    "@fastify/cors": "^8.2.1",
     "@fastify/deepmerge": "^1.3.0",
     "@fastify/restartable": "^1.4.0",
-    "@fastify/static": "^6.9.0",
+    "@fastify/static": "^6.10.1",
     "@fastify/swagger": "^8.3.1",
-    "@fastify/swagger-ui": "^1.4.0",
+    "@fastify/swagger-ui": "^1.8.0",
     "@fastify/under-pressure": "^8.2.0",
-    "@mercuriusjs/federation": "^1.0.1",
-    "close-with-grace": "^1.1.0",
+    "@mercuriusjs/federation": "^2.0.0",
+    "close-with-grace": "^1.2.0",
     "commist": "^3.2.0",
     "desm": "^1.3.0",
     "env-schema": "^5.2.0",
     "es-main": "^1.2.0",
-    "execa": "^7.0.0",
-    "fastify": "^4.13.0",
-    "fastify-metrics": "^10.0.3",
+    "execa": "^7.1.1",
+    "fastify": "^4.17.0",
+    "fastify-metrics": "^10.3.0",
     "fastify-plugin": "^4.5.0",
     "fastify-sandbox": "^0.11.0",
     "graphql": "^16.6.0",
     "help-me": "^4.2.0",
-    "mercurius": "^12.2.0",
+    "mercurius": "^13.0.0",
     "minimist": "^1.2.8",
     "pino": "^8.11.0",
     "pino-pretty": "^10.0.0",
     "rfdc": "^1.3.0",
-    "ua-parser-js": "^1.0.33",
-    "@platformatic/client": "0.21.0",
-    "@platformatic/config": "0.21.0",
-    "@platformatic/utils": "0.21.0"
+    "ua-parser-js": "^1.0.35",
+    "@platformatic/client": "0.22.0",
+    "@platformatic/config": "0.22.0",
+    "@platformatic/utils": "0.22.0"
   },
   "standard": {
     "ignore": [

package/test/cli/compile.test.mjs

@@ -88,10 +88,8 @@ t.test('should compile typescript plugin with start command', async (t) => {
 
   const splitter = split()
   child.stdout.pipe(splitter)
-  child.stderr.pipe(process.stderr)
 
   for await (const data of splitter) {
-    console.log(data)
     const sanitized = stripAnsi(data)
     if (sanitized.includes('Typescript plugin loaded')) {
       t.pass()
@@ -228,7 +226,6 @@ t.test('should compile typescript plugin with start command with different cwd',
   child.stderr.pipe(process.stderr)
 
   for await (const data of splitter) {
-    console.log(data)
     const sanitized = stripAnsi(data)
     if (sanitized.includes('Typescript plugin loaded')) {
       t.pass()

package/test/cli/start.test.mjs

@@ -30,6 +30,19 @@ test('start command', async ({ equal, same, match, teardown }) => {
   child.kill('SIGINT')
 })
 
+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')
+  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)
+  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'))
   match(url, /http:\/\/127.0.0.1:[0-9]+/)
@@ -38,7 +51,6 @@ test('default logger', async ({ equal, same, match, teardown }) => {
 
 test('plugin options', async ({ equal, same, match, teardown }) => {
   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()

package/test/cli/watch.test.mjs

@@ -11,6 +11,7 @@ t.jobs = 5
 function createLoggingPlugin (text, reloaded = false) {
   return `\
     module.exports = async (app) => {
+      app.log.info({ reloaded: ${reloaded}, text: '${text}' }, 'debugme')
       if (${reloaded}) {
         app.log.info('RELOADED')
       }
@@ -45,8 +46,6 @@ test('should watch js files by default', async ({ equal, teardown, comment }) =>
   ])
 
   const { child, url } = await start('-c', configFilePath)
-  child.stdout.pipe(process.stderr)
-  child.stderr.pipe(process.stderr)
   teardown(() => child.kill('SIGINT'))
 
   await writeFile(pluginFilePath, createLoggingPlugin('v2', true))

package/test/clients.test.js

@@ -9,7 +9,7 @@ const { compile } = require('../lib/compile')
 const { rmdir } = require('fs/promises')
 
 test('client is loaded', async ({ teardown, equal, pass, same, comment }) => {
-  const server1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'platformatic.service.json'))
+  const server1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'warn-log.service.json'))
   await server1.listen()
 
   process.env.PLT_CLIENT_URL = server1.url
@@ -28,7 +28,7 @@ test('client is loaded', async ({ teardown, equal, pass, same, comment }) => {
 })
 
 test('client is loaded (ts)', async ({ teardown, equal, pass, same }) => {
-  const server1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'platformatic.service.json'))
+  const server1 = await buildServer(join(__dirname, '..', 'fixtures', 'hello', 'warn-log.service.json'))
   await server1.listen()
 
   process.env.PLT_CLIENT_URL = server1.url
@@ -39,7 +39,7 @@ test('client is loaded (ts)', async ({ teardown, equal, pass, same }) => {
     await rmdir(join(targetDir, 'dist'))
   } catch {}
 
-  await compile(targetDir)
+  await compile(targetDir, { server: { logger: { level: 'warn' } } })
 
   const server2 = await buildServer(join(targetDir, 'platformatic.service.json'))
   teardown(async () => {

package/test/config.test.js

@@ -282,3 +282,71 @@ test('config reloads', async ({ teardown, equal, pass, same }) => {
     same(await res.body.text(), 'ciao mondo', 'response')
   }
 })
+
+test('restart throws if config is invalid', async ({ teardown, rejects }) => {
+  const server = await buildServer({
+    server: {
+      hostname: '127.0.0.1',
+      port: 0
+    }
+  })
+  teardown(server.stop)
+  await server.listen()
+
+  await rejects(server.restart({ foo: 'bar' }))
+})
+
+test('config reloads by calling restart', async ({ teardown, equal, pass, same }) => {
+  const file = join(os.tmpdir(), `${process.pid}-1.js`)
+
+  await writeFile(file, `
+    module.exports = async function (app, options) {
+      app.get('/', () => options.message)
+    }`)
+
+  const server = await buildServer({
+    server: {
+      hostname: '127.0.0.1',
+      port: 0
+    },
+    plugins: {
+      paths: [{
+        path: file,
+        options: {
+          message: 'hello'
+        }
+      }]
+    },
+    metrics: false
+  })
+  teardown(server.stop)
+  await server.listen()
+
+  {
+    const res = await request(`${server.url}/`)
+    equal(res.statusCode, 200, 'add status code')
+    same(await res.body.text(), 'hello', 'response')
+  }
+
+  await server.restart({
+    server: {
+      hostname: '127.0.0.1',
+      port: 0
+    },
+    plugins: {
+      paths: [{
+        path: file,
+        options: {
+          message: 'ciao mondo'
+        }
+      }]
+    },
+    metrics: false
+  })
+
+  {
+    const res = await request(`${server.url}/`)
+    equal(res.statusCode, 200, 'add status code')
+    same(await res.body.text(), 'ciao mondo', 'response')
+  }
+})

package/test/fixtures/custom-port-placeholder.json

@@ -0,0 +1,10 @@
+{
+  "server": {
+    "logger": {
+      "level": "info"
+    },
+    "hostname": "127.0.0.1",
+    "port": "{A_CUSTOM_PORT}",
+    "pluginTimeout": "10"
+  }
+}

package/test/https.test.js

@@ -2,7 +2,7 @@
 
 const { mkdtemp, writeFile } = require('fs/promises')
 const { tmpdir } = require('os')
-const { isAbsolute, join, relative } = require('path')
+const { join, relative } = require('path')
 const selfCert = require('self-cert')
 const { test } = require('tap')
 const { Agent, setGlobalDispatcher, request } = require('undici')
@@ -10,7 +10,7 @@ const { buildServer } = require('..')
 const { buildConfig } = require('./helper')
 
 test('supports https options', async ({ teardown, equal, same, plan, comment }) => {
-  plan(7)
+  plan(6)
 
   const { certificate, privateKey } = selfCert({})
   const localDir = tmpdir()
@@ -45,7 +45,6 @@ test('supports https options', async ({ teardown, equal, same, plan, comment })
   teardown(server.stop)
   await server.listen()
 
-  equal(isAbsolute(server.app.platformatic.configManager.current.server.https.cert[0].path), true)
   equal(server.url.startsWith('https://'), true)
   let res = await (request(`${server.url}/`))
   equal(res.statusCode, 200)

package/test/load-and-reload-files.test.js

@@ -111,6 +111,10 @@ test('update config', async ({ teardown, equal, pass, same }) => {
     }`)
 
   await server.restart({
+    server: {
+      hostname: '127.0.0.1',
+      port: 0
+    },
     plugins: {
       paths: [file2]
     }
@@ -248,7 +252,7 @@ test('load and reload ESM', async ({ teardown, equal, pass, same }) => {
   }
 })
 
-test('server should be available after reload a compromised plugin', async ({ teardown, equal, pass, same }) => {
+test('server should be available after reload a compromised plugin', async ({ teardown, equal, pass, same, rejects }) => {
   const file = join(os.tmpdir(), `some-plugin-${process.pid}.js`)
 
   const workingModule = `
@@ -285,7 +289,7 @@ test('server should be available after reload a compromised plugin', async ({ te
   }
 
   await writeFile(file, workingModule)
-  await server.restart(restartConfig)
+  await rejects(server.restart(restartConfig))
 
   {
     const res = await request(`${server.url}/`, { method: 'GET' })

package/test/utils.test.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { test } = require('tap')
-const { getJSPluginPath, findConfigFile, isFileAccessible } = require('../lib/utils')
+const { getJSPluginPath, isFileAccessible } = require('../lib/utils')
 const { join, resolve } = require('path')
 
 test('should get the path of a TS plugin', (t) => {
@@ -19,18 +19,9 @@ test('should get the path of a JS plugin', (t) => {
   t.equal(result, '/something/plugin.js')
 })
 
-test('findConfigFile', async (t) => {
-  const result = await findConfigFile(join(__dirname, '..', 'fixtures', 'hello'), [
-    'platformatic.service.json'
-  ])
-  t.equal(result, 'platformatic.service.json')
-})
-
-test('findConfigFile / failure', async (t) => {
-  const result = await findConfigFile(join(__dirname, '..', 'fixtures', 'hello'), [
-    'foobar'
-  ])
-  t.equal(result, undefined)
+test('isFileAccessible with dir', async (t) => {
+  const dir = resolve(join(__dirname, '..', 'fixtures', 'hello'))
+  t.equal(await isFileAccessible('platformatic.service.json', dir), true)
 })
 
 test('isFileAccessible no dir', async (t) => {