@platformatic/service 0.21.1 → 0.23.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,9 +3,10 @@
     "hostname": "127.0.0.1",
     "port": 0,
     "logger": {
-      "level": "info",
+      "level": "warn",
       "name": "hello client ts"
-    }
+    },
+    "pluginTimeout": 30000
   },
   "plugins": {
     "paths": ["./plugin.ts"],

package/index.js

@@ -1,170 +1,75 @@
 'use strict'
 
-const { start } = require('@fastify/restartable')
-const sandbox = require('fastify-sandbox')
-const underPressure = require('@fastify/under-pressure')
-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 compiler = require('./lib/compile')
-const { join, dirname, resolve } = require('path')
 const { readFile } = require('fs/promises')
-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) {
-      origin = new RegExp(origin.regexp)
-    }
-  }
+const ConfigManager = require('@platformatic/config')
+const { restartable } = require('@fastify/restartable')
+const { isKeyEnabled } = require('@platformatic/utils')
 
-  return origin
-}
+const compiler = require('./lib/compile')
+const setupCors = require('./lib/plugins/cors')
+const setupOpenAPI = require('./lib/plugins/openapi.js')
+const setupGraphQL = require('./lib/plugins/graphql.js')
+const setupClients = require('./lib/plugins/clients')
+const setupMetrics = require('./lib/plugins/metrics')
+const setupTsCompiler = require('./lib/plugins/typescript')
+const setupFileWatcher = require('./lib/plugins/file-watcher')
+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 { addLoggerToTheConfig } = require('./lib/utils')
 
 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(setupMetrics, 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 = 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 (isKeyEnabled('openapi', serviceConfig)) {
+    await app.register(setupOpenAPI, 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 (isKeyEnabled('graphql', serviceConfig)) {
+    await app.register(setupGraphQL, serviceConfig.graphql)
   }
 
-  for (const plugin of (app.platformatic.config.clients || [])) {
-    app.register(require(plugin.path), {
-      url: plugin.url
-    })
+  if (isKeyEnabled('clients', config)) {
+    app.register(setupClients, config.clients)
   }
 
-  if (opts.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 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) => {
-        if (typeof plugin === 'string') {
-          return getJSPluginPath(configPath, plugin, outDir)
-        } else {
-          return {
-            path: getJSPluginPath(configPath, plugin.path, outDir),
-            options: plugin.options
-          }
-        }
-      })
-    } else {
-      for (const plugin of opts.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`)
-        }
-      }
-    }
-
-    // if not defined, we default to true (which can happen only if config is set programmatically,
-    // 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')
-
-    if (isWatchEnabled && hotReload) {
-      await app.register(sandbox, {
-        path: wrapperPath,
-        options: { paths: opts.plugins.paths },
-        customizeGlobalThis (_globalThis) {
-          // Taken from https://github.com/nodejs/undici/blob/fa9fd9066569b6357acacffb806aa804b688c9d8/lib/global.js#L5
-          const globalDispatcher = Symbol.for('undici.globalDispatcher.1')
-          const dispatcher = globalThis[globalDispatcher]
-          /* istanbul ignore else */
-          if (dispatcher) {
-            _globalThis[globalDispatcher] = dispatcher
-          }
-        }
-      })
-    } else {
-      await app.register(require(wrapperPath), { paths: opts.plugins.paths })
+  if (config.plugins) {
+    if (config.plugins.typescript) {
+      await app.register(setupTsCompiler)
     }
+    await app.register(loadPlugins)
   }
 
-  // Enable CORS
-  if (opts.cors) {
-    let origin = opts.cors.origin
-    if (Array.isArray(origin)) {
-      origin = origin.map(originToRegexp)
-    } else {
-      origin = originToRegexp(origin)
-    }
-
-    opts.cors.origin = origin
+  if (isKeyEnabled('watch', config)) {
+    await app.register(setupFileWatcher, { onFilesUpdated })
+  }
 
-    app.register(require('@fastify/cors'), opts.cors)
+  if (config.server.cors) {
+    app.register(setupCors, config.server.cors)
   }
 
-  if (isKeyEnabled('healthCheck', opts)) {
-    app.register(underPressure, {
-      exposeStatusRoute: '/status',
-      healthCheckInterval: opts.healthCheck.interval !== undefined ? opts.healthCheck.interval : 5000,
-      ...opts.healthCheck,
-      healthCheck: opts.healthCheck.fn
-    })
+  if (isKeyEnabled('healthCheck', config.server)) {
+    app.register(setupHealthCheck, config.server.healthCheck)
   }
 
   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 +77,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
@@ -239,92 +113,128 @@ function defaultConfig (app, source) {
 async function buildServer (options, app) {
   app = app || platformaticService
 
-  if (!options.configManager) {
+  let configManager = options.configManager
+  if (!configManager) {
     // instantiate a new config manager from current options
-    const 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)
+    configManager = new ConfigManager(defaultConfig(app, options))
+    await configManager.parseAndValidate()
   }
 
-  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 = configManager.current
   }
-  const serverConfig = createServerConfig(options)
-
-  serverConfig.originalConfig = options
-  serverConfig.app = app
-  const handler = await start(serverConfig)
-
-  Object.defineProperty(handler, 'url', {
-    get () {
-      const protocol = serverConfig.protocol
-      const address = handler.address
-      const port = handler.port
-      const url = `${protocol}://${address}:${port}`
-      return url
-    }
-  })
 
-  const _restart = handler.restart
+  let url = null
 
-  let debounce = null
-  handler.restart = (opts) => {
-    /* c8 ignore next 3 */
-    if (debounce) {
-      return debounce
-    }
+  async function createRestartable (fastify) {
+    const config = configManager.current
+    const root = fastify(config.server)
 
-    addLoggerToTheConfig(opts)
-    const configManager = handler.app.platformatic.configManager
+    root.decorate('platformatic', { configManager, config })
+    root.register(app)
 
-    if (!opts) {
-      opts = configManager.current
+    root.decorate('url', {
+      getter () {
+        return url
+      }
+    })
+
+    if (root.restarted) {
+      root.log.info('restarted')
     }
 
-    // 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
-
-    debounce = _restart(opts).then(() => {
-      handler.app.log.info('restarted')
-    }).finally(() => {
-      debounce = null
-    })
-    return debounce
+    return root
   }
 
-  handler.app.restart = handler.restart
+  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
+  const configManager = app.platformatic.configManager
+  try {
+    app.log.debug('files changed')
+    await configManager.parse()
+    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 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')
+  }
+}
+
 // This is for @platformatic/db to use
 /* c8 ignore next 4 */
-async function buildStart (loadConfig, buildServer) {
+async function buildStart (loadConfig, buildServer, configManagerConfig) {
   const { buildStart } = await import('./lib/start.mjs')
-  return buildStart(loadConfig, buildServer)
+  return buildStart(loadConfig, buildServer, configManagerConfig)
 }
 
 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,8 +20,13 @@ function generateDefaultConfig () {
 
 // Unfortunately c8 does not see those on Windows
 /* c8 ignore next 70 */
-async function loadConfig (minimistConfig, _args, defaultConfig, configFileNames = ourConfigFiles) {
-  defaultConfig ??= generateDefaultConfig()
+async function loadConfig (minimistConfig, _args, defaultConfig, configType = 'service') {
+  if (defaultConfig === undefined) {
+    defaultConfig = generateDefaultConfig()
+  } else if (defaultConfig?.mergeDefaults) {
+    defaultConfig = { ...generateDefaultConfig(), ...defaultConfig }
+  }
+
   const args = parseArgs(_args, deepmerge({ all: true })({
     string: ['allow-env'],
     boolean: ['hotReload'],
@@ -49,22 +44,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/plugins/clients.js

@@ -0,0 +1,12 @@
+'use strict'
+
+const fp = require('fastify-plugin')
+
+async function setupClients (app, opts) {
+  const clientsConfig = opts
+  for (const { path, url } of clientsConfig) {
+    app.register(require(path), { url })
+  }
+}
+
+module.exports = fp(setupClients)

package/lib/plugins/cors.js

@@ -0,0 +1,29 @@
+'use strict'
+
+const fp = require('fastify-plugin')
+
+function originToRegexp (origin) {
+  if (typeof origin === 'object') {
+    if (origin.regexp) {
+      origin = new RegExp(origin.regexp)
+    }
+  }
+
+  return origin
+}
+
+async function setupClients (app, opts) {
+  const cors = opts
+
+  let origin = cors.origin
+  if (Array.isArray(origin)) {
+    origin = origin.map(originToRegexp)
+  } else {
+    origin = originToRegexp(origin)
+  }
+
+  cors.origin = origin
+  app.register(require('@fastify/cors'), cors)
+}
+
+module.exports = fp(setupClients)

package/lib/plugins/file-watcher.js

@@ -0,0 +1,44 @@
+'use strict'
+
+const { FileWatcher } = require('@platformatic/utils')
+const fp = require('fastify-plugin')
+
+async function setupFileWatcher (app, opts) {
+  // TODO: move params to opts
+
+  const configManager = app.platformatic.configManager
+  const config = configManager.current
+
+  const isRestartableApp = app.restarted !== undefined
+
+  // to run the plugin without restartable
+  /* c8 ignore next 1 */
+  const persistentRef = isRestartableApp ? app.persistentRef : app
+
+  let fileWatcher = persistentRef.fileWatcher
+  if (!fileWatcher) {
+    fileWatcher = new FileWatcher({
+      path: configManager.dirname,
+      allowToWatch: config.watch?.allow,
+      watchIgnore: config.watch?.ignore
+    })
+
+    fileWatcher.on('update', () => {
+      opts.onFilesUpdated(persistentRef)
+    })
+
+    app.log.debug('start watching files')
+    fileWatcher.startWatching()
+  }
+
+  app.decorate('fileWatcher', fileWatcher)
+
+  app.addHook('onClose', async () => {
+    if (!isRestartableApp || app.closingRestartable) {
+      app.fileWatcher.stopWatching()
+      app.log.debug('stop watching files')
+    }
+  })
+}
+
+module.exports = fp(setupFileWatcher)