@platformatic/runtime 0.26.1 → 0.28.1

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 { dirname, basename } = require('node:path')
+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,15 @@ class PlatformaticApp {
     this.server = null
     this.#started = false
     this.#originalWatch = null
+    this.#logger = logger
+  }
+
+  getStatus () {
+    if (this.#started) {
+      return 'started'
+    } else {
+      return 'stopped'
+    }
   }
 
   async restart (force) {
@@ -55,12 +62,15 @@ class PlatformaticApp {
       throw new Error('application is already started')
     }
 
-    await this.#initializeConfig()
+    if (!this.#restarting) {
+      await this.#initializeConfig()
+    }
     const { configManager } = this.config
     const config = configManager.current
 
     this.#originalWatch = config.watch
     config.watch = false
+    this.#setuplogger(configManager)
 
     try {
       // If this is a restart, have the fastify server restart itself. If this
@@ -77,9 +87,6 @@ class PlatformaticApp {
       this.#logAndExit(err)
     }
 
-    this.server.platformatic.configManager = configManager
-    this.server.platformatic.config = config
-
     if (config.plugins !== undefined && this.#originalWatch !== false) {
       this.#startFileWatching()
     }
@@ -110,26 +117,11 @@ class PlatformaticApp {
     this.#started = false
   }
 
-  async handleProcessLevelEvent ({ msg, signal, err }) {
-    if (msg === 'plt:start') {
-      await this.start()
-      return
-    }
-
+  async handleProcessLevelEvent ({ signal, err }) {
     if (!this.server) {
       return false
     }
 
-    if (msg === 'plt:restart') {
-      await this.restart(true)
-      return
-    }
-
-    if (msg === 'plt:stop') {
-      await this.stop()
-      return
-    }
-
     if (signal === 'SIGUSR2') {
       this.server.log.info('reloading configuration')
       await this.restart()
@@ -161,53 +153,43 @@ class PlatformaticApp {
         return appConfig.localServiceEnvVars.get(key)
       }
     })
-    const { args, configManager } = this.config
+    const { configManager } = this.config
 
-    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
-
-          for (let i = 0; next !== undefined && i < parts.length; ++i) {
-            obj = next
-            next = obj[parts[i]]
-          }
-
-          if (next !== undefined) {
-            obj[parts.at(-1)] = value
-          }
-        })
-      } catch (err) {
-        configManager.stopWatching()
-        throw err
+    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
+
+            for (let i = 0; next !== undefined && i < parts.length; ++i) {
+              obj = next
+              next = obj[parts[i]]
+            }
+
+            if (next !== undefined) {
+              obj[parts.at(-1)] = value
+            }
+          })
+        } catch (err) {
+          configManager.stopWatching()
+          throw err
+        }
       }
     }
 
-    // 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.#hotReload = args.hotReload && this.appConfig.hotReload
+    applyOverrides()
 
-    if (configManager.current.plugins) {
-      if (this.#hotReload) {
-        this.#hotReload = configManager.current.plugins.hotReload
-      }
-
-      configManager.current.plugins.hotReload = false
-    }
+    this.#hotReload = this.appConfig.hotReload
 
     configManager.on('update', async (newConfig) => {
-      /* c8 ignore next 4 */
       this.server.platformatic.config = newConfig
+      applyOverrides()
       this.server.log.debug('config changed')
       this.server.log.trace({ newConfig }, 'new config')
       await this.restart()
@@ -219,14 +201,26 @@ 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
+    // 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
+      watchIgnore: [...(this.#originalWatch?.ignore || []), basename(configManager.fullPath)]
     })
 
     fileWatcher.on('update', async () => {
@@ -253,7 +247,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/config.js

@@ -1,6 +1,6 @@
 'use strict'
 const { readFile, readdir } = require('node:fs/promises')
-const { join, resolve: pathResolve } = require('node:path')
+const { basename, join, resolve: pathResolve } = require('node:path')
 const Topo = require('@hapi/topo')
 const ConfigManager = require('@platformatic/config')
 const { schema } = require('./schema')
@@ -101,7 +101,7 @@ async function parseClientsAndComposer (configManager) {
             }
 
             if (dep.origin === `{${err.key}}`) {
-              service.localServiceEnvVars.set(err.key, `${clientName}.plt.local`)
+              service.localServiceEnvVars.set(err.key, `http://${clientName}.plt.local`)
             }
           }
         }
@@ -118,6 +118,7 @@ async function parseClientsAndComposer (configManager) {
       const promises = parsed.clients.map((client) => {
         // eslint-disable-next-line no-async-promise-executor
         return new Promise(async (resolve, reject) => {
+          let clientName = client.serviceId ?? ''
           let clientUrl
           let missingKey
 
@@ -135,11 +136,15 @@ async function parseClientsAndComposer (configManager) {
           }
 
           const isLocal = missingKey && client.url === `{${missingKey}}`
-          const clientAbsolutePath = pathResolve(service.path, client.path)
-          const clientPackageJson = join(clientAbsolutePath, 'package.json')
-          const clientMetadata = JSON.parse(await readFile(clientPackageJson, 'utf8'))
+
           /* c8 ignore next 20 - unclear why c8 is unhappy for nearly 20 lines here */
-          const clientName = clientMetadata.name ?? ''
+          if (!clientName) {
+            const clientAbsolutePath = pathResolve(service.path, client.path)
+            const clientPackageJson = join(clientAbsolutePath, 'package.json')
+            const clientMetadata = JSON.parse(await readFile(clientPackageJson, 'utf8'))
+
+            clientName = clientMetadata.name ?? ''
+          }
 
           if (clientUrl === undefined) {
             // Combine the service name with the client name to avoid collisions
@@ -156,8 +161,8 @@ async function parseClientsAndComposer (configManager) {
 
           const dependency = configManager.current.serviceMap.get(clientName)
 
+          /* c8 ignore next 4 */
           if (dependency === undefined) {
-            /* c8 ignore next 3 */
             reject(new Error(`service '${service.id}' has unknown dependency: '${clientName}'`))
             return
           }
@@ -206,4 +211,27 @@ platformaticRuntime.configManagerConfig = {
   }
 }
 
-module.exports = { platformaticRuntime }
+async function wrapConfigInRuntimeConfig ({ configManager, args }) {
+  /* c8 ignore next */
+  const id = basename(configManager.dirname) || 'main'
+  const wrapperConfig = {
+    $schema: schema.$id,
+    entrypoint: id,
+    allowCycles: false,
+    hotReload: true,
+    services: [
+      {
+        id,
+        path: configManager.dirname,
+        config: configManager.fullPath
+      }
+    ]
+  }
+  const cm = new ConfigManager({ source: wrapperConfig, schema })
+
+  await _transformConfig(cm)
+  await cm.parseAndValidate()
+  return cm
+}
+
+module.exports = { platformaticRuntime, wrapConfigInRuntimeConfig }

package/lib/loader.mjs

@@ -1,16 +1,17 @@
 import { createRequire, isBuiltin } from 'node:module'
 import { dirname, isAbsolute, resolve as pathResolve } from 'node:path'
-import { fileURLToPath } from 'node:url'
+import { fileURLToPath, pathToFileURL } from 'node:url'
 const require = createRequire(import.meta.url)
-const thisFile = fileURLToPath(import.meta.url)
 const isWindows = process.platform === 'win32'
 let timestamp = process.hrtime.bigint()
 let port
 
+/* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
 function bustEsmCache () {
   timestamp = process.hrtime.bigint()
 }
 
+/* c8 ignore next 11 - c8 upgrade marked many existing things as uncovered */
 function clearCjsCache () {
   // This evicts all of the modules from the require() cache.
   // Note: This does not clean up children references to the deleted module.
@@ -25,6 +26,7 @@ function clearCjsCache () {
 
 function isRelativePath (p) {
   // This function is extracted from Node core, so it should work.
+  /* c8 ignore next - c8 upgrade marked many existing things as uncovered */
   return p.charAt(0) === '.' &&
     /* c8 ignore next 9 */
     (
@@ -38,15 +40,15 @@ function isRelativePath (p) {
     )
 }
 
-function specifierToPath (specifier, referencingModuleId) {
-  // Convert the specifier into an absolute path if possible. If the specifier
-  // cannot be converted to a path (for example for a core module), then return
-  // null.
+function specifierToFileUrl (specifier, referencingModuleId) {
+  // Convert the specifier into an absolute path URL if possible. If the
+  // specifier cannot be converted to a path (for example for a core module),
+  // then return null.
   try {
     const url = new URL(specifier)
 
     if (url.protocol === 'file:') {
-      specifier = url.pathname
+      return url.href
     } else {
       return null
     }
@@ -54,12 +56,14 @@ function specifierToPath (specifier, referencingModuleId) {
     // Ignore error.
   }
 
+  /* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
   if (isBuiltin(specifier)) {
     return null
   }
 
+  /* c8 ignore next 3 */
   if (isAbsolute(specifier)) {
-    return specifier
+    return pathToFileURL(specifier).href
   }
 
   /* c8 ignore next 3 */
@@ -67,31 +71,35 @@ function specifierToPath (specifier, referencingModuleId) {
     throw new Error(`cannot map '${specifier}' to an absolute path`)
   }
 
+  /* c8 ignore next 5 - c8 upgrade marked many existing things as uncovered */
   if (isRelativePath(specifier)) {
-    return pathResolve(dirname(fileURLToPath(referencingModuleId)), specifier)
+    return pathToFileURL(
+      pathResolve(dirname(fileURLToPath(referencingModuleId)), specifier)
+    ).href
   } else {
     // The specifier is something in node_modules/.
     const req = createRequire(referencingModuleId)
 
-    return req.resolve(specifier)
+    return pathToFileURL(req.resolve(specifier)).href
   }
 }
 
 export async function resolve (specifier, context, nextResolve) {
-  const path = specifierToPath(specifier, context.parentURL)
+  const url = specifierToFileUrl(specifier, context.parentURL)
 
   // If the specifier could not be mapped to a file, or the path is this file,
   // then don't do anything.
-  if (typeof path !== 'string' || path === thisFile) {
+  if (typeof url !== 'string' || url === import.meta.url) {
     return nextResolve(specifier, context)
   }
 
-  return nextResolve(`${path}?ts=${timestamp}`, context)
+  return nextResolve(`${url}?ts=${timestamp}`, context)
 }
 
 export function globalPreload (context) {
   port = context.port
   port.on('message', () => {
+    /* c8 ignore next 3 - c8 upgrade marked many existing things as uncovered */
     bustEsmCache()
     clearCjsCache()
     port.postMessage('plt:cache-cleared')

package/lib/start.js

@@ -1,11 +1,13 @@
 'use strict'
 const { once } = require('node:events')
 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 { platformaticRuntime } = require('./config')
-const kLoaderFile = join(__dirname, 'loader.mjs')
+const { RuntimeApiClient } = require('./api.js')
+const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href
 const kWorkerFile = join(__dirname, 'worker.js')
 const kWorkerExecArgv = [
   '--no-warnings',
@@ -35,8 +37,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)
   })
 
@@ -56,22 +58,8 @@ async function startWithConfig (configManager) {
 
   await once(worker, 'message') // plt:init
 
-  return {
-    async start () {
-      worker.postMessage({ msg: 'plt:start' })
-      const [msg] = await once(worker, 'message') // plt:started
-
-      return msg.url
-    },
-    async close () {
-      worker.postMessage({ msg: 'plt:stop' })
-      await once(worker, 'exit')
-    },
-    async restart () {
-      worker.postMessage({ msg: 'plt:restart' })
-      await once(worker, 'message') // plt:restarted
-    }
-  }
+  const runtimeApiClient = new RuntimeApiClient(worker)
+  return runtimeApiClient
 }
 
 module.exports = { start, startWithConfig }

package/lib/unified-api.js

@@ -0,0 +1,198 @@
+'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, wrapConfigInRuntimeConfig } = require('./config')
+const { schema: runtimeSchema } = require('./schema')
+const {
+  start: runtimeStart,
+  startWithConfig: runtimeStartWithConfig
+} = 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) {
+    logErrorAndExit(err)
+  }
+}
+
+async function startCommandInRuntime (args) {
+  try {
+    const configType = await getConfigType(args)
+    const config = await _loadConfig({}, args, configType)
+    let runtime
+
+    if (configType === 'runtime') {
+      runtime = await runtimeStartWithConfig(config.configManager)
+    } else {
+      const wrappedConfig = await wrapConfigInRuntimeConfig(config)
+      runtime = await runtimeStartWithConfig(wrappedConfig)
+    }
+
+    return await runtime.start()
+  } catch (err) {
+    logErrorAndExit(err)
+  }
+}
+
+function logErrorAndExit (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,
+  startCommandInRuntime,
+  getApp
+}