@platformatic/runtime 0.35.5 → 0.37.0

package/fixtures/stackables/node_modules/foo/foo.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { schema } = require('@platformatic/service')
+
+/**  @type {import('fastify').FastifyPluginAsync<{}>} */
+async function foo (app) {
+  const text = app.platformatic.config.foo.text
+  app.get('/foo', async (request, reply) => {
+    return text
+  })
+}
+
+foo.configType = 'foo'
+foo.schema = {
+  $id: 'https://example.com/schemas/foo.json',
+  title: 'Platformatic Service',
+  type: 'object',
+  properties: {
+    server: schema.server,
+    plugins: schema.plugins,
+    metrics: schema.metrics,
+    watch: {
+      anyOf: [schema.watch, {
+        type: 'boolean'
+      }, {
+        type: 'string'
+      }]
+    },
+    $schema: {
+      type: 'string'
+    },
+    module: {
+      type: 'string'
+    },
+    foo: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string'
+        }
+      },
+      required: ['text']
+    }
+  },
+  additionalProperties: false,
+  required: ['server']
+}
+
+foo.configManagerConfig = {
+  schema: foo.schema,
+  envWhitelist: ['PORT', 'HOSTNAME'],
+  allowToWatch: ['.env'],
+  schemaOptions: {
+    useDefaults: true,
+    coerceTypes: true,
+    allErrors: true,
+    strict: false
+  }
+}
+
+module.exports = foo

package/fixtures/stackables/node_modules/foo/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "main": "foo.js"
+}

package/fixtures/stackables/platformatic.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://example.com/schemas/foo.json",
+  "module": "foo",
+  "server": {
+    "port": 0,
+    "hostname": "127.0.0.1"
+  },
+  "foo": {
+    "text": "Hello World"
+  }
+}

package/lib/api.js

@@ -193,7 +193,7 @@ class RuntimeApi {
     }
 
     if (typeof service.server.swagger !== 'function') {
-      throw new Error(`Service with id '${id}' does not expose an OpenAPI schema`)
+      return null
     }
 
     try {

package/lib/app.js

@@ -1,7 +1,7 @@
 'use strict'
 
 const { once } = require('node:events')
-const { dirname, basename } = require('node:path')
+const { dirname } = require('node:path')
 const { FileWatcher } = require('@platformatic/utils')
 const debounce = require('debounce')
 const {
@@ -18,6 +18,7 @@ class PlatformaticApp {
   #fileWatcher
   #logger
   #telemetryConfig
+  #debouncedRestart
 
   constructor (appConfig, loaderPort, logger, telemetryConfig) {
     this.appConfig = appConfig
@@ -33,6 +34,12 @@ class PlatformaticApp {
       name: this.appConfig.id
     })
     this.#telemetryConfig = telemetryConfig
+
+    /* c8 ignore next 4 */
+    this.#debouncedRestart = debounce(() => {
+      this.server.log.info('files changed')
+      this.restart()
+    }, 100) // debounce restart for 100ms
   }
 
   getStatus () {
@@ -56,8 +63,9 @@ class PlatformaticApp {
       await once(this.#loaderPort, 'message')
     }
 
-    this.#setuplogger(this.config.configManager)
     try {
+      await this.config.configManager.parseAndValidate()
+      this.#setuplogger(this.config.configManager)
       await this.server.restart()
     } catch (err) {
       this.#logAndExit(err)
@@ -90,6 +98,7 @@ class PlatformaticApp {
       // If this is a restart, have the fastify server restart itself. If this
       // is not a restart, then create a new server.
       this.server = await buildServer({
+        app: this.config.app,
         ...config,
         configManager
       })
@@ -157,8 +166,7 @@ class PlatformaticApp {
 
     let _config
     try {
-      _config = await loadConfig({}, ['-c', appConfig.config], null, {
-        watch: true,
+      _config = await loadConfig({}, ['-c', appConfig.config], {
         onMissingEnv (key) {
           return appConfig.localServiceEnvVars.get(key)
         }
@@ -172,30 +180,25 @@ class PlatformaticApp {
 
     function applyOverrides () {
       if (appConfig._configOverrides instanceof Map) {
-        try {
-          appConfig._configOverrides.forEach((value, key) => {
-            if (typeof key !== 'string') {
-              throw new Error('config path must be a string.')
-            }
-
-            const parts = key.split('.')
-            let next = configManager.current
-            let obj
-            let i
-
-            for (i = 0; next !== undefined && i < parts.length; ++i) {
-              obj = next
-              next = obj[parts[i]]
-            }
-
-            if (i === parts.length) {
-              obj[parts.at(-1)] = value
-            }
-          })
-        } catch (err) {
-          configManager.stopWatching()
-          throw err
-        }
+        appConfig._configOverrides.forEach((value, key) => {
+          if (typeof key !== 'string') {
+            throw new Error('config path must be a string.')
+          }
+
+          const parts = key.split('.')
+          let next = configManager.current
+          let obj
+          let i
+
+          for (i = 0; next !== undefined && i < parts.length; ++i) {
+            obj = next
+            next = obj[parts[i]]
+          }
+
+          if (i === parts.length) {
+            obj[parts.at(-1)] = value
+          }
+        })
       }
     }
 
@@ -203,16 +206,6 @@ class PlatformaticApp {
 
     this.#hotReload = this.appConfig.hotReload
 
-    configManager.on('update', async (newConfig) => {
-      if (this.server) { // when we setup telemetry on config, we don't have a server yet
-        this.server.platformatic.config = newConfig
-        applyOverrides()
-        this.server.log.debug('config changed')
-        this.server.log.trace({ newConfig }, 'new config')
-        await this.restart()
-      }
-    })
-
     configManager.on('error', (err) => {
       /* c8 ignore next */
       this.server.log.error({ err }, 'error reloading the configuration')
@@ -233,34 +226,22 @@ class PlatformaticApp {
     }
     const server = this.server
     const { configManager } = server.platformatic
-    // TODO FileWatcher and ConfigManager both watch the configuration file
-    // we should remove the watching from the ConfigManager
     const fileWatcher = new FileWatcher({
       path: dirname(configManager.fullPath),
       /* c8 ignore next 2 */
       allowToWatch: this.#originalWatch?.allow,
-      watchIgnore: [...(this.#originalWatch?.ignore || []), basename(configManager.fullPath)]
+      watchIgnore: this.#originalWatch?.ignore || []
     })
 
-    /* c8 ignore next 4 */
-    const restart = debounce(() => {
-      this.server.log.info('files changed')
-      this.restart()
-    }, 100) // debounce restart for 100ms
-    fileWatcher.on('update', restart)
+    fileWatcher.on('update', this.#debouncedRestart)
 
     fileWatcher.startWatching()
     server.log.debug('start watching files')
     server.platformatic.fileWatcher = fileWatcher
-    server.platformatic.configManager.startWatching()
     this.#fileWatcher = fileWatcher
   }
 
   async #stopFileWatching () {
-    // The configManager automatically watches for the config file changes
-    // therefore we need to stop it all the times.
-    await this.config.configManager.stopWatching()
-
     const watcher = this.#fileWatcher
     if (watcher) {
       this.server.log.debug('stop watching files')
@@ -271,7 +252,6 @@ class PlatformaticApp {
   }
 
   #logAndExit (err) {
-    this.config?.configManager?.stopWatching()
     this.#logger.error({ err })
     process.exit(1)
   }

package/lib/compile.js

@@ -9,7 +9,7 @@ const pretty = require('pino-pretty')
 const { isatty } = require('node:tty')
 
 async function compile (argv, logger) {
-  const { configManager, configType } = await loadConfig({}, argv, undefined, {
+  const { configManager, configType } = await loadConfig({}, argv, {
     watch: false
   })
 
@@ -33,7 +33,7 @@ async function compile (argv, logger) {
     for (const service of configManager.current.services) {
       const childLogger = logger.child({ name: service.id })
 
-      const serviceConfig = await loadConfig({}, argv, undefined, {
+      const serviceConfig = await loadConfig({}, argv, {
         watch: false
       })
 

package/lib/start.js

@@ -5,7 +5,7 @@ const { join } = require('node:path')
 const { pathToFileURL } = require('node:url')
 const { Worker } = require('node:worker_threads')
 const closeWithGrace = require('close-with-grace')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { parseInspectorOptions, platformaticRuntime } = require('./config')
 const RuntimeApiClient = require('./api-client.js')
 const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href

package/lib/unified-api.js

@@ -1,112 +1,41 @@
 'use strict'
-const { resolve } = require('node:path')
-const parseArgs = require('minimist')
-const ConfigManager = require('@platformatic/config')
+const { Store, loadConfig, printConfigValidationErrors } = require('@platformatic/config')
 const {
   platformaticService,
   buildServer,
-  loadConfig,
-  start,
-  schema: serviceSchema
+  start
 } = require('@platformatic/service')
 const {
-  schema: dbSchema,
   platformaticDB
 } = require('@platformatic/db')
 const {
-  schema: composerSchema,
   platformaticComposer
 } = require('@platformatic/composer')
 const { buildServer: runtimeBuildServer } = require('./build-server')
 const { platformaticRuntime, wrapConfigInRuntimeConfig } = require('./config')
-const { schema: runtimeSchema } = require('./schema')
 const {
   start: runtimeStart,
   startWithConfig: runtimeStartWithConfig
 } = require('./start')
 
-const kSupportedAppTypes = new Set(['service', 'db', 'composer', 'runtime'])
+const store = new Store()
+store.add(platformaticService)
+store.add(platformaticDB)
+store.add(platformaticComposer)
+store.add(platformaticRuntime)
 
-async function tryGetConfigTypeFromSchema (config) {
-  /* c8 ignore next 6 - c8 is not seeing this as covered for some reason. */
-  if (typeof config === 'string') {
-    // Handle config file paths.
-    const loadedConfig = await loadConfig({}, ['-c', config], platformaticService)
-
-    config = loadedConfig.configManager.current
-  }
-
-  const schema = config?.$schema
-
-  if (typeof schema !== 'string') {
-    throw new Error('configuration is missing a schema')
-  }
-
-  const configType = schema.split('/').pop()
-
-  if (!kSupportedAppTypes.has(configType)) {
-    throw new Error(`unknown configuration type: '${configType}'`)
-  }
-
-  return configType
-}
-
-async function getConfigType (args = [], directory) {
-  try {
-    // The config type was not specified, so we need to figure it out.
-    // Try to get the config file from the provided arguments.
-    let { config } = parseArgs(args, { alias: { c: 'config' } })
-
-    if (!config) {
-      // Couldn't get the config file from the arguments, so look in the
-      // provided directory (or current directory) for any recognized
-      // config files.
-      const searchDir = directory ?? process.cwd()
-      const configFile = await ConfigManager.findConfigFile(searchDir)
-
-      config = resolve(searchDir, configFile)
-    }
-
-    // At this point, we have the config file. However, several different
-    // file formats are supported, so use the config manager to parse the
-    // file (without worrying about the validity of the file). We can then
-    // use the $schema field to determine the config type.
-    const configManager = new ConfigManager({ source: config })
-    const configString = await configManager.load()
-    const parsedConfig = configManager._parser(configString)
-
-    return await tryGetConfigTypeFromSchema(parsedConfig)
-  } catch (err) {
-    const configFiles = ConfigManager.listConfigFiles()
-    const msg = `
-Missing config file!
-Be sure to have a config file with one of the following names:
-${configFiles.map((s) => ' * ' + s).join('\n')}
-Alternatively run "npm create platformatic@latest" to generate a basic plt service config.
-`
-
-    throw new Error(msg, { cause: err })
-  }
-}
-
-async function getCurrentSchema (configType) {
-  if (configType === 'service') {
-    return serviceSchema.schema
-  } else if (configType === 'db') {
-    return dbSchema
-  } else if (configType === 'composer') {
-    return composerSchema
-  } else if (configType === 'runtime') {
-    return runtimeSchema
+/* c8 ignore next 10 - for some reason c8 is not seeing this as covered. */
+async function _buildServer (options) {
+  if (typeof options === 'string') {
+    const config = await _loadConfig({}, ['-c', options])
+    options = config.configManager.current
+    options.configManager = config.configManager
+    options.app = config.app
   }
 
-  throw new Error(`unknown configuration type: '${configType}'`)
-}
+  const app = options.app
 
-/* c8 ignore next 10 - for some reason c8 is not seeing this as covered. */
-async function _buildServer (options) {
-  const configType = await tryGetConfigTypeFromSchema(options)
-  const app = getApp(configType)
+  delete options.app
 
   if (app === platformaticRuntime) {
     return runtimeBuildServer(options)
@@ -115,51 +44,26 @@ async function _buildServer (options) {
   return buildServer(options, app)
 }
 
-function getApp (configType) {
-  if (configType === 'service') {
-    return platformaticService
-  } else if (configType === 'db') {
-    return platformaticDB
-  } else if (configType === 'composer') {
-    return platformaticComposer
-  } else if (configType === 'runtime') {
-    return platformaticRuntime
-  }
-
-  throw new Error('unknown kind: ' + configType)
-}
-
-async function _loadConfig (minimistConfig, args, configType, overrides) {
-  // If the config type was specified, then use that. Otherwise, compute it.
-  if (typeof configType !== 'string') {
-    configType = await getConfigType(args)
-  }
-
-  const app = getApp(configType)
-  const res = await loadConfig(minimistConfig, args, app, overrides)
-  res.configType = configType
-  res.app = app
-
-  return res
+function _loadConfig (minimistConfig, args, overrides) {
+  return loadConfig(minimistConfig, args, store, overrides)
 }
 
 async function _start (args) {
-  const configType = await getConfigType(args)
+  const config = await _loadConfig({}, args)
 
-  if (configType === 'runtime') {
+  if (config.configType === 'runtime') {
     return runtimeStart(args)
   }
 
-  return start(getApp(configType), args)
+  return start(config.app, args)
 }
 
 async function startCommand (args) {
   try {
-    const configType = await getConfigType(args)
-    const config = await _loadConfig({}, args, configType)
+    const config = await _loadConfig({}, args)
     let runtime
 
-    if (configType === 'runtime') {
+    if (config.configType === 'runtime') {
       config.configManager.args = config.args
       runtime = await runtimeStartWithConfig(config.configManager)
     } else {
@@ -175,6 +79,19 @@ async function startCommand (args) {
 }
 
 function logErrorAndExit (err) {
+  if (err.filenames) {
+    console.error(`Missing config file!
+Be sure to have a config file with one of the following names:
+
+${err.filenames.map((s) => ' * ' + s).join('\n')}
+
+In alternative run "npm create platformatic@latest" to generate a basic plt service config.`)
+    process.exit(1)
+  } else if (err.validationErrors) {
+    printConfigValidationErrors(err)
+    process.exit(1)
+  }
+
   delete err?.stack
   console.error(err?.message)
 
@@ -187,10 +104,7 @@ function logErrorAndExit (err) {
 
 module.exports = {
   buildServer: _buildServer,
-  getConfigType,
-  getCurrentSchema,
   loadConfig: _loadConfig,
   start: _start,
-  startCommand,
-  getApp
+  startCommand
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.35.5",
+  "version": "0.37.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -24,8 +24,8 @@
     "standard": "^17.1.0",
     "tsd": "^0.28.1",
     "typescript": "^5.1.6",
-    "@platformatic/sql-graphql": "0.35.5",
-    "@platformatic/sql-mapper": "0.35.5"
+    "@platformatic/sql-graphql": "0.37.0",
+    "@platformatic/sql-mapper": "0.37.0"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -42,12 +42,12 @@
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "undici": "^5.22.1",
-    "@platformatic/composer": "0.35.5",
-    "@platformatic/config": "0.35.5",
-    "@platformatic/db": "0.35.5",
-    "@platformatic/service": "0.35.5",
-    "@platformatic/telemetry": "0.35.5",
-    "@platformatic/utils": "0.35.5"
+    "@platformatic/composer": "0.37.0",
+    "@platformatic/config": "0.37.0",
+    "@platformatic/db": "0.37.0",
+    "@platformatic/service": "0.37.0",
+    "@platformatic/telemetry": "0.37.0",
+    "@platformatic/utils": "0.37.0"
   },
   "standard": {
     "ignore": [

package/test/api.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
 
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { buildServer, platformaticRuntime } = require('..')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 
@@ -349,9 +349,6 @@ test('should fail to get a service openapi schema if service does not expose it'
     await app.close()
   })
 
-  try {
-    await app.getServiceOpenapiSchema('without-openapi')
-  } catch (err) {
-    assert.strictEqual(err.message, 'Service with id \'without-openapi\' does not expose an OpenAPI schema')
-  }
+  const openapiSchema = await app.getServiceOpenapiSchema('without-openapi')
+  assert.strictEqual(openapiSchema, null)
 })

package/test/cli/start.test.mjs

@@ -48,6 +48,10 @@ test('handles startup errors', async (t) => {
   }
 
   assert(found)
+
+  // if we do not await this, the test will crash because the event loop has nothing to do
+  // but there is still a promise waiting
+  await child.catch(() => {})
 })
 
 test('exits on error', async () => {
@@ -115,3 +119,13 @@ test('starts the inspector', async (t) => {
   assert(found)
   child.kill('SIGINT')
 })
+
+test('stackable', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'stackables', 'platformatic.json')
+  const { child, url } = await start('start', '-c', config)
+  const res = await request(url + '/foo')
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.text(), 'Hello World')
+  child.kill('SIGINT')
+})

package/test/config.test.js

@@ -3,7 +3,8 @@
 const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
-const { loadConfig, platformaticService } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
+const { platformaticService } = require('@platformatic/service')
 const { parseInspectorOptions, platformaticRuntime } = require('../lib/config')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 

package/test/start.test.js

@@ -6,7 +6,8 @@ const { join } = require('node:path')
 const { test } = require('node:test')
 const { MessageChannel } = require('node:worker_threads')
 const { request } = require('undici')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
+const { platformaticDB } = require('@platformatic/db')
 const { buildServer, platformaticRuntime } = require('..')
 const { wrapConfigInRuntimeConfig } = require('../lib/config')
 const { startWithConfig } = require('../lib/start')
@@ -160,7 +161,7 @@ test('handles uncaught exceptions with db app', async (t) => {
 
 test('logs errors during db migrations', async (t) => {
   const configFile = join(fixturesDir, 'dbAppWithMigrationError', 'platformatic.db.json')
-  const config = await loadConfig({}, ['-c', configFile], 'db')
+  const config = await loadConfig({}, ['-c', configFile], platformaticDB)
   const runtimeConfig = await wrapConfigInRuntimeConfig(config)
   const { port1, port2 } = new MessageChannel()
   runtimeConfig.current.loggingPort = port2

package/test/telemetry.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert')
 const { request } = require('undici')
 const { test } = require('node:test')
 const { join } = require('node:path')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { platformaticRuntime } = require('..')
 const { startWithConfig } = require('../lib/start')
 const fixturesDir = join(__dirname, '..', 'fixtures')

package/test/unified-api.test.js

@@ -6,117 +6,10 @@ const { join } = require('node:path')
 const { test } = require('node:test')
 const {
   buildServer,
-  getConfigType,
-  getCurrentSchema,
   loadConfig
 } = require('../lib/unified-api')
-const { version } = require('../package.json')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 
-test('getConfigType()', async (t) => {
-  await t.test('throws if there is no $schema', async () => {
-    const configFile = join(fixturesDir, 'configs', 'no-schema.config.json')
-    let err
-
-    try {
-      await getConfigType(['-c', configFile])
-    } catch (error) {
-      err = error
-    }
-
-    assert(err)
-    assert.strictEqual(err.cause.message, 'configuration is missing a schema')
-  })
-
-  await t.test('throws if the schema type is unsupported', async () => {
-    const configFile = join(fixturesDir, 'configs', 'invalid-schema-type.config.json')
-    let err
-
-    try {
-      await getConfigType(['-c', configFile])
-    } catch (error) {
-      err = error
-    }
-
-    assert(err)
-    assert.strictEqual(err.cause.message, 'unknown configuration type: \'trickortreat\'')
-  })
-
-  await t.test('gets type from config via args', async () => {
-    const configFile = join(fixturesDir, 'monorepo', 'serviceApp', 'platformatic.service.json')
-    const type = await getConfigType(['-c', configFile])
-
-    assert.strictEqual(type, 'service')
-  })
-
-  await t.test('gets type from config in provided directory', async () => {
-    const configDir = join(fixturesDir, 'monorepo', 'serviceApp')
-    const type = await getConfigType(undefined, configDir)
-
-    assert.strictEqual(type, 'service')
-  })
-
-  await t.test('gets db type from config in cwd', async (t) => {
-    const cwd = process.cwd()
-
-    t.after(() => {
-      process.chdir(cwd)
-    })
-
-    const configDir = join(fixturesDir, 'dbApp')
-    process.chdir(configDir)
-    const type = await getConfigType()
-
-    assert.strictEqual(type, 'db')
-  })
-
-  await t.test('gets composer type from config in cwd', async (t) => {
-    const cwd = process.cwd()
-
-    t.after(() => {
-      process.chdir(cwd)
-    })
-
-    const configDir = join(fixturesDir, 'monorepo', 'composerApp')
-    process.chdir(configDir)
-    const type = await getConfigType()
-
-    assert.strictEqual(type, 'composer')
-  })
-})
-
-test('getCurrentSchema()', async (t) => {
-  await t.test('gets service schema', async () => {
-    const schema = await getCurrentSchema('service')
-
-    assert(schema.$id.endsWith(`/v${version}/service`))
-  })
-
-  await t.test('gets db schema', async () => {
-    const schema = await getCurrentSchema('db')
-
-    assert(schema.$id.endsWith(`/v${version}/db`))
-  })
-
-  await t.test('gets composer schema', async () => {
-    const schema = await getCurrentSchema('composer')
-
-    assert(schema.$id.endsWith(`/v${version}/composer`))
-  })
-
-  await t.test('gets runtime schema', async () => {
-    const schema = await getCurrentSchema('runtime')
-
-    assert(schema.$id.endsWith(`/v${version}/runtime`))
-  })
-
-  await t.test('throws for unknown types', async () => {
-    await assert.rejects(async () => {
-      await getCurrentSchema('not-a-real-type')
-    }, /unknown configuration type/)
-  })
-})
-
 test('loadConfig()', async (t) => {
   await t.test('can explicitly provide config type', async () => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
@@ -128,18 +21,6 @@ test('loadConfig()', async (t) => {
     assert.strictEqual(config.configManager.schemaOptions.useDefaults, true)
   })
 
-  await t.test('throws if explicit type is wrong', async () => {
-    // Prevent the failed validation from logging and exiting the process.
-    t.mock.method(process, 'exit', () => {})
-    t.mock.method(console, 'table', () => {})
-
-    const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
-
-    await assert.rejects(async () => {
-      await loadConfig({}, ['-c', configFile], 'kaboom')
-    })
-  })
-
   await t.test('can load a platformatic service project', async () => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
     const config = await loadConfig({}, ['-c', configFile])
@@ -182,7 +63,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a service server', async (t) => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -196,7 +80,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a db server', async (t) => {
     const configFile = join(fixturesDir, 'dbApp', 'platformatic.db.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -210,7 +97,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a composer server', async (t) => {
     const configFile = join(fixturesDir, 'composerApp', 'platformatic.composer.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -224,7 +114,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a runtime application', async (t) => {
     const configFile = join(fixturesDir, 'configs', 'monorepo.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -244,6 +137,9 @@ test('buildServer()', async (t) => {
     })
 
     const address = await server.start()
+
+    assert.strictEqual(server.platformatic.configManager.fullPath, configFile)
+
     // The address should be a valid URL.
     new URL(address) // eslint-disable-line no-new
   })