@platformatic/runtime 0.26.0 → 0.27.0

package/fixtures/composerApp/api1.json

@@ -0,0 +1,65 @@
+{
+  "openapi": "3.0.3",
+  "info": {
+    "version": "8.3.1",
+    "title": "@fastify/swagger"
+  },
+  "components": {
+    "schemas": {}
+  },
+  "paths": {
+    "/users": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "post": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "put": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      }
+    },
+    "/users/{id}": {
+      "get": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "post": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "put": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      },
+      "delete": {
+        "responses": {
+          "200": {
+            "description": "Default Response"
+          }
+        }
+      }
+    }
+  }
+}

package/fixtures/composerApp/platformatic.composer.json

@@ -0,0 +1,23 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.23.2/composer",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "info"
+    }
+  },
+  "composer": {
+    "services": [
+      {
+        "id": "api1",
+        "origin": "http://127.0.0.1",
+        "openapi": {
+          "file": "./api1.json"
+        }
+      }
+    ],
+    "refreshTimeout": 1000
+  },
+  "watch": false
+}

package/fixtures/configs/invalid-schema-type.config.json

@@ -0,0 +1,20 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.22.0/trickortreat",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0,
+    "logger": {
+      "level": "info",
+      "name": "hello server"
+    }
+  },
+  "plugins": {
+    "paths": ["./plugin.js"],
+    "hotReload": false
+  },
+  "service": {
+    "openapi": true
+  },
+  "metrics": false,
+  "watch": false
+}

package/fixtures/configs/no-schema.config.json

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

package/fixtures/dbApp/platformatic.db.json

@@ -0,0 +1,22 @@
+{
+  "$schema": "https://platformatic.dev/schemas/v0.22.0/db",
+  "server": {
+    "hostname": "127.0.0.1",
+    "port": 0
+  },
+  "migrations": {
+    "dir": "migrations",
+    "table": "versions"
+  },
+  "types": {
+    "autogenerate": false
+  },
+  "db": {
+    "connectionString": "sqlite://db.sqlite",
+    "graphql": true,
+    "ignore": {
+      "versions": true
+    },
+    "events": false
+  }
+}

package/fixtures/start-command.js

@@ -0,0 +1,9 @@
+'use strict'
+const { startCommand } = require('../lib/unified-api')
+
+async function main () {
+  await startCommand(['-c', process.argv[2]])
+  process.exit(42)
+}
+
+main()

package/fixtures/starter.js

@@ -0,0 +1,9 @@
+'use strict'
+const { start } = require('../lib/unified-api')
+
+async function main () {
+  await start(['-c', process.argv[2]])
+  process.exit(42)
+}
+
+main()

package/index.js

@@ -1,33 +1,13 @@
 'use strict'
-const ConfigManager = require('@platformatic/config')
+const { buildServer } = require('./lib/build-server')
 const { platformaticRuntime } = require('./lib/config')
-const { start, startWithConfig } = require('./lib/start')
-
-async function buildServer (options = {}) {
-  if (!options.configManager) {
-    // Instantiate a new config manager from the current options.
-    const cm = new ConfigManager({
-      ...platformaticRuntime.configManagerConfig,
-      source: options
-    })
-    await cm.parseAndValidate()
-
-    if (typeof options === 'string') {
-      options = { configManager: cm }
-    } else {
-      options.configManager = cm
-    }
-  }
-
-  // The transformConfig() function can't be sent between threads.
-  delete options.configManager._transformConfig
-
-  return startWithConfig(options.configManager)
-}
+const { start } = require('./lib/start')
+const unifiedApi = require('./lib/unified-api')
 
 module.exports = {
   buildServer,
   platformaticRuntime,
   schema: platformaticRuntime.schema,
-  start
+  start,
+  unifiedApi
 }

package/lib/app.js

@@ -1,14 +1,11 @@
 'use strict'
 const { once } = require('node:events')
 const { dirname } = require('node:path')
-const {
-  addLoggerToTheConfig
-} = require('@platformatic/service')
+const { FileWatcher } = require('@platformatic/utils')
 const {
   buildServer,
   loadConfig
-} = require('@platformatic/start')
-const { FileWatcher } = require('@platformatic/utils')
+} = require('./unified-api')
 
 class PlatformaticApp {
   #hotReload
@@ -16,8 +13,9 @@ class PlatformaticApp {
   #restarting
   #started
   #originalWatch
+  #logger
 
-  constructor (appConfig, loaderPort) {
+  constructor (appConfig, loaderPort, logger) {
     this.appConfig = appConfig
     this.config = null
     this.#hotReload = false
@@ -26,6 +24,7 @@ class PlatformaticApp {
     this.server = null
     this.#started = false
     this.#originalWatch = null
+    this.#logger = logger
   }
 
   async restart (force) {
@@ -61,6 +60,7 @@ class PlatformaticApp {
 
     this.#originalWatch = config.watch
     config.watch = false
+    this.#setuplogger(configManager)
 
     try {
       // If this is a restart, have the fastify server restart itself. If this
@@ -189,11 +189,7 @@ class PlatformaticApp {
       }
     }
 
-    // Set the logger if not present (and the config supports it).
-    if (configManager.current.server) {
-      addLoggerToTheConfig(configManager.current)
-      configManager.current.server.logger.name = this.appConfig.id
-    }
+    this.#setuplogger(configManager)
 
     this.#hotReload = args.hotReload && this.appConfig.hotReload
 
@@ -219,6 +215,16 @@ class PlatformaticApp {
     })
   }
 
+  #setuplogger (configManager) {
+    // Set the logger if not present (and the config supports it).
+    if (configManager.current.server) {
+      const childLogger = this.#logger.child({
+        name: this.appConfig.id
+      }, { level: configManager.current.server.logger?.level || 'info' })
+      configManager.current.server.logger = childLogger
+    }
+  }
+
   #startFileWatching () {
     const server = this.server
     const { configManager } = server.platformatic
@@ -253,7 +259,7 @@ class PlatformaticApp {
 
   #logAndExit (err) {
     this.config?.configManager?.stopWatching()
-    console.error(err)
+    this.#logger.error({ err })
     process.exit(1)
   }
 }

package/lib/build-server.js

@@ -0,0 +1,28 @@
+'use strict'
+const ConfigManager = require('@platformatic/config')
+const { platformaticRuntime } = require('./config')
+const { startWithConfig } = require('./start')
+
+async function buildServer (options = {}) {
+  if (!options.configManager) {
+    // Instantiate a new config manager from the current options.
+    const cm = new ConfigManager({
+      ...platformaticRuntime.configManagerConfig,
+      source: options
+    })
+    await cm.parseAndValidate()
+
+    if (typeof options === 'string') {
+      options = { configManager: cm }
+    } else {
+      options.configManager = cm
+    }
+  }
+
+  // The transformConfig() function can't be sent between threads.
+  delete options.configManager._transformConfig
+
+  return startWithConfig(options.configManager)
+}
+
+module.exports = { buildServer }

package/lib/start.js

@@ -35,8 +35,8 @@ async function startWithConfig (configManager) {
     configManager.fileWatcher?.stopWatching()
   })
 
-  worker.on('error', (err) => {
-    console.error(err)
+  worker.on('error', () => {
+    // the error is logged in the worker
     process.exit(1)
   })
 

package/lib/unified-api.js

@@ -0,0 +1,171 @@
+'use strict'
+const { resolve } = require('node:path')
+const parseArgs = require('minimist')
+const ConfigManager = require('@platformatic/config')
+const {
+  platformaticService,
+  buildServer,
+  loadConfig,
+  start,
+  schema: serviceSchema
+} = 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 } = require('./config')
+const { schema: runtimeSchema } = require('./schema')
+const { start: runtimeStart } = require('./start')
+
+const kSupportedAppTypes = new Set(['service', 'db', 'composer', 'runtime'])
+
+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
+  }
+
+  throw new Error(`unknown configuration type: '${configType}'`)
+}
+
+/* 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)
+
+  if (app === platformaticRuntime) {
+    return runtimeBuildServer(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)
+  }
+
+  return loadConfig(minimistConfig, args, getApp(configType), overrides)
+}
+
+async function _start (args) {
+  const configType = await getConfigType(args)
+
+  if (configType === 'runtime') {
+    return runtimeStart(args)
+  }
+
+  return start(getApp(configType), args)
+}
+
+async function startCommand (args) {
+  try {
+    await _start(args)
+  } catch (err) {
+    delete err?.stack
+    console.error(err?.message)
+
+    if (err?.cause) {
+      console.error(`${err.cause}`)
+    }
+
+    process.exit(1)
+  }
+}
+
+module.exports = {
+  buildServer: _buildServer,
+  getConfigType,
+  getCurrentSchema,
+  loadConfig: _loadConfig,
+  start: _start,
+  startCommand,
+  getApp
+}

package/lib/worker.js

@@ -10,12 +10,38 @@ const globalDispatcher = new FastifyUndiciDispatcher({
   // setting the domain here allows for fail-fast scenarios
   domain: '.plt.local'
 })
+const pino = require('pino')
+const { isatty } = require('tty')
+
 const applications = new Map()
 let entrypoint
 
 delete globalThis.LOADER_PORT
 setGlobalDispatcher(globalDispatcher)
 
+let transport
+
+/* c8 ignore next 5 */
+if (isatty(1)) {
+  transport = pino.transport({
+    target: 'pino-pretty'
+  })
+}
+
+const logger = pino(transport)
+
+process.once('uncaughtException', (err) => {
+  logger.error({ err }, 'runtime error')
+  throw err
+})
+
+// Tested by test/cli/start.test.mjs by C8 does not see it.
+/* c8 ignore next 4 */
+process.once('unhandledRejection', (err) => {
+  logger.error({ err }, 'runtime error')
+  throw err
+})
+
 parentPort.on('message', async (msg) => {
   for (const app of applications.values()) {
     await app.handleProcessLevelEvent(msg)
@@ -39,6 +65,7 @@ parentPort.on('message', async (msg) => {
     case 'plt:stop':
       process.exit() // Exit the worker thread.
       break
+      /* c8 ignore next 3 */
     case undefined:
       // Ignore
       break
@@ -52,7 +79,7 @@ async function main () {
 
   for (let i = 0; i < services.length; ++i) {
     const service = services[i]
-    const app = new PlatformaticApp(service, loaderPort)
+    const app = new PlatformaticApp(service, loaderPort, logger)
 
     applications.set(service.id, app)
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.26.0",
+  "version": "0.27.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -17,12 +17,12 @@
   },
   "homepage": "https://github.com/platformatic/platformatic#readme",
   "devDependencies": {
-    "c8": "^7.13.0",
-    "execa": "^7.0.0",
+    "c8": "^8.0.0",
+    "execa": "^7.1.1",
     "snazzy": "^9.0.0",
-    "split2": "^4.1.0",
-    "standard": "^17.0.0",
-    "tsd": "^0.28.0"
+    "split2": "^4.2.0",
+    "standard": "^17.1.0",
+    "tsd": "^0.28.1"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -30,15 +30,18 @@
     "commist": "^3.2.0",
     "desm": "^1.3.0",
     "es-main": "^1.2.0",
-    "fastify": "^4.17.0",
-    "fastify-undici-dispatcher": "^0.4.0",
+    "fastify": "^4.18.0",
+    "fastify-undici-dispatcher": "^0.4.1",
     "help-me": "^4.2.0",
     "minimist": "^1.2.8",
-    "undici": "^5.20.0",
-    "@platformatic/config": "0.26.0",
-    "@platformatic/service": "0.26.0",
-    "@platformatic/start": "0.26.0",
-    "@platformatic/utils": "0.26.0"
+    "pino": "^8.14.1",
+    "pino-pretty": "^10.0.0",
+    "undici": "^5.22.1",
+    "@platformatic/composer": "0.27.0",
+    "@platformatic/config": "0.27.0",
+    "@platformatic/db": "0.27.0",
+    "@platformatic/service": "0.27.0",
+    "@platformatic/utils": "0.27.0"
   },
   "standard": {
     "ignore": [

package/test/app.test.js

@@ -5,8 +5,17 @@ const { join } = require('node:path')
 const { test } = require('node:test')
 const { PlatformaticApp } = require('../lib/app')
 const fixturesDir = join(__dirname, '..', 'fixtures')
+const pino = require('pino')
+const split = require('split2')
+
+function getLoggerAndStream () {
+  const stream = split(JSON.parse)
+  const logger = pino(stream)
+  return { logger, stream }
+}
 
 test('logs errors during startup', async (t) => {
+  const { logger, stream } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'serviceAppThrowsOnStart')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -16,9 +25,8 @@ test('logs errors during startup', async (t) => {
     entrypoint: true,
     hotReload: true
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
-  t.mock.method(console, 'error', () => {})
   t.mock.method(process, 'exit', () => { throw new Error('exited') })
 
   await assert.rejects(async () => {
@@ -26,11 +34,18 @@ test('logs errors during startup', async (t) => {
   }, /exited/)
   assert.strictEqual(process.exit.mock.calls.length, 1)
   assert.strictEqual(process.exit.mock.calls[0].arguments[0], 1)
-  assert.strictEqual(console.error.mock.calls.length, 1)
-  assert.strictEqual(console.error.mock.calls[0].arguments[0].message, 'boom')
+
+  stream.end()
+  const lines = []
+  for await (const line of stream) {
+    lines.push(line)
+  }
+  const lastLine = lines[lines.length - 1]
+  assert.strictEqual(lastLine.msg, 'boom')
 })
 
 test('errors when starting an already started application', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -43,7 +58,7 @@ test('errors when starting an already started application', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -53,6 +68,7 @@ test('errors when starting an already started application', async (t) => {
 })
 
 test('errors when stopping an already stopped application', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -65,7 +81,7 @@ test('errors when stopping an already stopped application', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   await assert.rejects(async () => {
     await app.stop()
@@ -73,6 +89,7 @@ test('errors when stopping an already stopped application', async (t) => {
 })
 
 test('does not restart while restarting', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -85,7 +102,7 @@ test('does not restart while restarting', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -101,6 +118,7 @@ test('does not restart while restarting', async (t) => {
 })
 
 test('restarts on SIGUSR2', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -113,7 +131,7 @@ test('restarts on SIGUSR2', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(app.stop.bind(app))
   await app.start()
@@ -123,6 +141,7 @@ test('restarts on SIGUSR2', async (t) => {
 })
 
 test('stops on signals other than SIGUSR2', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -135,7 +154,7 @@ test('stops on signals other than SIGUSR2', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(async () => {
     try {
@@ -151,6 +170,7 @@ test('stops on signals other than SIGUSR2', async (t) => {
 })
 
 test('stops on uncaught exceptions', async (t) => {
+  const { logger } = getLoggerAndStream()
   const appPath = join(fixturesDir, 'monorepo', 'serviceApp')
   const configFile = join(appPath, 'platformatic.service.json')
   const config = {
@@ -163,7 +183,7 @@ test('stops on uncaught exceptions', async (t) => {
     dependents: [],
     localServiceEnvVars: new Map([['PLT_WITH_LOGGER_URL', ' ']])
   }
-  const app = new PlatformaticApp(config, null)
+  const app = new PlatformaticApp(config, null, logger)
 
   t.after(async () => {
     try {
@@ -193,8 +213,9 @@ test('supports configuration overrides', async (t) => {
   }
 
   await t.test('throws on non-string config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([[null, 5]])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {
@@ -210,8 +231,9 @@ test('supports configuration overrides', async (t) => {
   })
 
   await t.test('ignores invalid config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([['foo.bar.baz', 5]])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {
@@ -225,11 +247,12 @@ test('supports configuration overrides', async (t) => {
   })
 
   await t.test('sets valid config paths', async (t) => {
+    const { logger } = getLoggerAndStream()
     config._configOverrides = new Map([
       ['server.keepAliveTimeout', 1],
       ['server.port', 0]
     ])
-    const app = new PlatformaticApp(config, null)
+    const app = new PlatformaticApp(config, null, logger)
 
     t.after(async () => {
       try {

package/test/cli/start.test.mjs

@@ -29,14 +29,14 @@ test('handles startup errors', async (t) => {
   const { execa } = await import('execa')
   const config = join(import.meta.url, '..', '..', 'fixtures', 'configs', 'service-throws-on-start.json')
   const child = execa(process.execPath, [cliPath, 'start', '-c', config], { encoding: 'utf8' })
-  let stderr = ''
+  let stdout = ''
   let found = false
 
-  for await (const messages of on(child.stderr, 'data')) {
+  for await (const messages of on(child.stdout, 'data')) {
     for (const message of messages) {
-      stderr += message
+      stdout += message
 
-      if (/Error: boom/.test(stderr)) {
+      if (/Error: boom/.test(stdout)) {
         found = true
         break
       }

package/test/unified-api.test.js

@@ -0,0 +1,321 @@
+'use strict'
+const assert = require('node:assert')
+const { spawn } = require('node:child_process')
+const { once } = require('node:events')
+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')
+    const config = await loadConfig({}, ['-c', configFile], undefined, 'service')
+
+    assert.strictEqual(config.args.config, configFile)
+    assert.strictEqual(config.configManager.fullPath, configFile)
+    assert.strictEqual(config.configManager.current.server.logger.name, 'service-with-logger')
+    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])
+
+    assert.strictEqual(config.args.config, configFile)
+    assert.strictEqual(config.configManager.fullPath, configFile)
+    assert.strictEqual(config.configManager.current.server.logger.name, 'service-with-logger')
+    assert.strictEqual(config.configManager.schemaOptions.useDefaults, true)
+  })
+
+  await t.test('can load a platformatic db project', async () => {
+    const configFile = join(fixturesDir, 'dbApp', 'platformatic.db.json')
+    const config = await loadConfig({}, ['-c', configFile])
+
+    assert.strictEqual(config.args.config, configFile)
+    assert.strictEqual(config.configManager.fullPath, configFile)
+    assert.strictEqual(config.configManager.current.db.graphql, true)
+  })
+
+  await t.test('can load a platformatic composer project', async () => {
+    const configFile = join(fixturesDir, 'composerApp', 'platformatic.composer.json')
+    const config = await loadConfig({}, ['-c', configFile])
+
+    assert.strictEqual(config.args.config, configFile)
+    assert.strictEqual(config.configManager.fullPath, configFile)
+    assert.strictEqual(config.configManager.current.composer.refreshTimeout, 1000)
+  })
+
+  await t.test('can load a platformatic runtime project', async () => {
+    const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+    const config = await loadConfig({}, ['-c', configFile])
+
+    assert.strictEqual(config.args.config, configFile)
+    assert.strictEqual(config.configManager.fullPath, configFile)
+    assert.strictEqual(config.configManager.current.entrypoint, 'serviceApp')
+  })
+})
+
+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)
+
+    t.after(async () => {
+      await server.close()
+    })
+
+    const address = await server.start()
+    // The address should be a valid URL.
+    new URL(address) // eslint-disable-line no-new
+  })
+
+  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)
+
+    t.after(async () => {
+      await server.close()
+    })
+
+    const address = await server.start()
+    // The address should be a valid URL.
+    new URL(address) // eslint-disable-line no-new
+  })
+
+  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)
+
+    t.after(async () => {
+      await server.close()
+    })
+
+    const address = await server.start()
+    // The address should be a valid URL.
+    new URL(address) // eslint-disable-line no-new
+  })
+
+  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)
+
+    t.after(async () => {
+      await server.close()
+    })
+
+    const address = await server.start()
+    // The address should be a valid URL.
+    new URL(address) // eslint-disable-line no-new
+  })
+
+  await t.test('input can be a filename', async (t) => {
+    const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
+    const server = await buildServer(configFile)
+
+    t.after(async () => {
+      await server.close()
+    })
+
+    const address = await server.start()
+    // The address should be a valid URL.
+    new URL(address) // eslint-disable-line no-new
+  })
+})
+
+test('start()', async (t) => {
+  await t.test('can start a service server', async (t) => {
+    const scriptFile = join(fixturesDir, 'starter.js')
+    const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    child.stdout.pipe(process.stdout)
+    child.stderr.pipe(process.stderr)
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+
+  await t.test('can start a db server', async (t) => {
+    const scriptFile = join(fixturesDir, 'starter.js')
+    const configFile = join(fixturesDir, 'dbApp', 'platformatic.db.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+
+  await t.test('can start a composer server', async () => {
+    const scriptFile = join(fixturesDir, 'starter.js')
+    const configFile = join(fixturesDir, 'composerApp', 'platformatic.composer.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+
+  await t.test('can start a runtime application', async () => {
+    const scriptFile = join(fixturesDir, 'starter.js')
+    const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+})
+
+test('startCommand()', async (t) => {
+  await t.test('can start a server', async (t) => {
+    const scriptFile = join(fixturesDir, 'start-command.js')
+    const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    child.stderr.pipe(process.stderr)
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+
+  await t.test('exits on error', async (t) => {
+    const scriptFile = join(fixturesDir, 'start-command.js')
+    const configFile = join(fixturesDir, 'serviceApp', 'platformatic.not-found.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 1)
+  })
+
+  await t.test('can start a runtime application', async (t) => {
+    const scriptFile = join(fixturesDir, 'start-command.js')
+    const configFile = join(fixturesDir, 'configs', 'monorepo.json')
+    const child = spawn(process.execPath, [scriptFile, configFile])
+    child.stderr.pipe(process.stderr)
+    const [exitCode] = await once(child, 'exit')
+
+    assert.strictEqual(exitCode, 42)
+  })
+})