@platformatic/runtime 1.53.3 → 2.0.0-alpha.10

package/lib/app.js

@@ -1,365 +0,0 @@
-'use strict'
-
-const { dirname } = require('node:path')
-const { EventEmitter, once } = require('node:events')
-const { FileWatcher } = require('@platformatic/utils')
-const debounce = require('debounce')
-const { buildServer } = require('./build-server')
-const { loadConfig } = require('./load-config')
-const errors = require('./errors')
-
-class PlatformaticApp extends EventEmitter {
-  #hotReload
-  #loaderPort
-  #starting
-  #started
-  #originalWatch
-  #fileWatcher
-  #logger
-  #telemetryConfig
-  #serverConfig
-  #debouncedRestart
-  #hasManagementApi
-  #metricsConfig
-
-  constructor (appConfig, loaderPort, logger, telemetryConfig, serverConfig, hasManagementApi, metricsConfig) {
-    super()
-    this.appConfig = appConfig
-    this.config = null
-    this.#hotReload = false
-    this.#loaderPort = loaderPort
-    this.#starting = false
-    this.#started = false
-    this.server = null
-    this.#originalWatch = null
-    this.#fileWatcher = null
-    this.#hasManagementApi = !!hasManagementApi
-    this.#logger = logger.child({
-      name: this.appConfig.id
-    })
-    this.#telemetryConfig = telemetryConfig
-    this.#metricsConfig = metricsConfig
-    this.#serverConfig = serverConfig
-
-    /* c8 ignore next 4 */
-    this.#debouncedRestart = debounce(() => {
-      this.server.log.info('files changed')
-      this.restart()
-    }, 100) // debounce restart for 100ms
-  }
-
-  getStatus () {
-    if (this.#starting) return 'starting'
-    if (this.#started) return 'started'
-    return 'stopped'
-  }
-
-  async restart (force) {
-    if (this.#starting || !this.#started || (!this.#hotReload && !force)) {
-      return
-    }
-
-    this.#starting = true
-    this.#started = false
-
-    // The CJS cache should not be cleared from the loader because v20 moved
-    // the loader to a different thread with a different CJS cache.
-    clearCjsCache()
-
-    /* c8 ignore next 4 - tests may not pass in a MessagePort. */
-    if (this.#loaderPort) {
-      this.#loaderPort.postMessage('plt:clear-cache')
-      await once(this.#loaderPort, 'message')
-    }
-
-    try {
-      await this.config.configManager.parseAndValidate()
-      await this.#updateConfig()
-
-      this.#setuplogger(this.config.configManager)
-      await this.server.restart()
-    } catch (err) {
-      // The restart failed. Log the error and
-      // wait for another event.
-      // The old app is still available
-      this.#logger.error({ err })
-    }
-
-    this.#started = true
-    this.#starting = false
-    this.emit('start')
-    this.emit('restart')
-  }
-
-  async start () {
-    if (this.#starting || this.#started) {
-      throw new errors.ApplicationAlreadyStartedError()
-    }
-
-    this.#starting = true
-
-    await this.#initializeConfig()
-    await this.#updateConfig()
-
-    const configManager = this.config.configManager
-    const config = configManager.current
-
-    this.#setuplogger(configManager)
-
-    try {
-      // 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,
-        id: this.appConfig.id,
-        configManager
-      })
-    } catch (err) {
-      this.#logAndExit(err)
-    }
-
-    if (
-      (
-        config.plugins !== undefined ||
-        config.versions !== undefined
-      ) &&
-      this.#originalWatch?.enabled !== false
-    ) {
-      this.#startFileWatching()
-    }
-
-    if (this.appConfig.entrypoint || this.appConfig.useHttp) {
-      try {
-        await this.server.start()
-        /* c8 ignore next 5 */
-      } catch (err) {
-        this.server.log.error({ err })
-        this.#starting = false
-        throw err
-      }
-    } else {
-      // Make sure the server has run all the onReady hooks before returning.
-      await this.server.ready()
-    }
-
-    this.#started = true
-    this.#starting = false
-    this.emit('start')
-  }
-
-  async stop () {
-    if (!this.#started || this.#starting) {
-      throw new errors.ApplicationNotStartedError()
-    }
-
-    await this.#stopFileWatching()
-    await this.server.close()
-
-    this.#started = false
-    this.#starting = false
-    this.emit('stop')
-  }
-
-  async handleProcessLevelEvent ({ signal, err }) {
-    /* c8 ignore next 3 */
-    if (!this.server) {
-      return false
-    }
-
-    if (signal === 'SIGUSR2') {
-      this.server.log.info('reloading configuration')
-      await this.restart()
-      return false
-    }
-
-    if (err) {
-      this.server.log.error({
-        err: {
-          message: err?.message,
-          stack: err?.stack
-        }
-      }, 'exiting')
-    } else if (signal) {
-      this.server.log.info({ signal }, 'received signal')
-    }
-
-    if (this.#starting) {
-      await once(this, 'start')
-    }
-
-    if (this.#started) {
-      await this.stop()
-      this.server.log.info('server stopped')
-    }
-  }
-
-  async #initializeConfig () {
-    const appConfig = this.appConfig
-
-    let _config
-    try {
-      _config = await loadConfig({}, ['-c', appConfig.config], {
-        onMissingEnv (key) {
-          return appConfig.localServiceEnvVars.get(key)
-        }
-      }, true, this.#logger)
-    } catch (err) {
-      this.#logAndExit(err)
-    }
-
-    this.config = _config
-    const { configManager } = this.config
-
-    function applyOverrides () {
-      if (appConfig._configOverrides instanceof Map) {
-        appConfig._configOverrides.forEach((value, key) => {
-          if (typeof key !== 'string') {
-            throw new errors.ConfigPathMustBeStringError()
-          }
-
-          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
-          }
-        })
-      }
-    }
-
-    applyOverrides()
-
-    this.#hotReload = this.appConfig.hotReload
-
-    configManager.on('error', (err) => {
-      /* c8 ignore next */
-      this.server.log.error({ err }, 'error reloading the configuration')
-    })
-  }
-
-  async #updateConfig () {
-    this.#originalWatch = this.config.configManager.current.watch
-    this.config.configManager.current.watch = { enabled: false }
-
-    const { configManager } = this.config
-    configManager.update({
-      ...configManager.current,
-      telemetry: this.#telemetryConfig,
-      metrics: this.#metricsConfig
-    })
-
-    if (configManager.current.metrics !== false) {
-      configManager.update({
-        ...configManager.current,
-        metrics: this.#metricsConfig
-      })
-    }
-
-    if (this.#serverConfig) {
-      configManager.update({
-        ...configManager.current,
-        server: this.#serverConfig
-      })
-    }
-
-    if (
-      (this.#hasManagementApi && configManager.current.metrics === undefined) ||
-      configManager.current.metrics
-    ) {
-      const labels = configManager.current.metrics?.labels || {}
-      const serviceId = this.appConfig.id
-      configManager.update({
-        ...configManager.current,
-        metrics: {
-          server: 'hide',
-          defaultMetrics: { enabled: this.appConfig.entrypoint },
-          ...configManager.current.metrics,
-          labels: {
-            serviceId,
-            ...labels
-          }
-        }
-      })
-    }
-
-    if (!this.appConfig.entrypoint) {
-      configManager.update({
-        ...configManager.current,
-        server: {
-          ...(configManager.current.server || {}),
-          trustProxy: true
-        }
-      })
-    }
-  }
-
-  #setuplogger (configManager) {
-    configManager.current.server = configManager.current.server || {}
-    const level = configManager.current.server.logger?.level
-
-    configManager.current.server.logger = level
-      ? this.#logger.child({ level })
-      : this.#logger
-  }
-
-  #startFileWatching () {
-    if (this.#fileWatcher) {
-      return
-    }
-    const server = this.server
-    const { configManager } = server.platformatic
-    const fileWatcher = new FileWatcher({
-      path: dirname(configManager.fullPath),
-      /* c8 ignore next 2 */
-      allowToWatch: this.#originalWatch?.allow,
-      watchIgnore: this.#originalWatch?.ignore || []
-    })
-
-    fileWatcher.on('update', this.#debouncedRestart)
-
-    fileWatcher.startWatching()
-    server.log.debug('start watching files')
-    server.platformatic.fileWatcher = fileWatcher
-    this.#fileWatcher = fileWatcher
-  }
-
-  async #stopFileWatching () {
-    const watcher = this.#fileWatcher
-    if (watcher) {
-      this.server.log.debug('stop watching files')
-      await watcher.stopWatching()
-      this.server.platformatic.fileWatcher = undefined
-      this.#fileWatcher = null
-    }
-  }
-
-  #logAndExit (err) {
-    this.#logger.error({ err })
-    process.exit(1)
-  }
-}
-
-/* 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.
-  // It's likely not a big deal for most cases, but it is a leak. The child
-  // references can be cleaned up, but it is expensive and involves walking
-  // the entire require() cache. See the DEP0144 documentation for how to do
-  // it.
-  Object.keys(require.cache).forEach((key) => {
-    if (!key.match(/node_modules/)) {
-      delete require.cache[key]
-    }
-  })
-}
-
-module.exports = { PlatformaticApp }

package/lib/load-config.js

@@ -1,20 +0,0 @@
-'use strict'
-
-const { Store, loadConfig } = require('@platformatic/config')
-
-const { platformaticService } = require('@platformatic/service')
-const { platformaticDB } = require('@platformatic/db')
-const { platformaticComposer } = require('@platformatic/composer')
-const { platformaticRuntime } = require('./config')
-
-const store = new Store()
-store.add(platformaticService)
-store.add(platformaticDB)
-store.add(platformaticComposer)
-store.add(platformaticRuntime)
-
-function _loadConfig (minimistConfig, args, overrides, replaceEnv = true) {
-  return loadConfig(minimistConfig, args, store, overrides, replaceEnv)
-}
-
-module.exports = { loadConfig: _loadConfig }

package/lib/loader.mjs

@@ -1,103 +0,0 @@
-import { createRequire, isBuiltin } from 'node:module'
-import { dirname, isAbsolute, resolve as pathResolve } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import errors from './errors.js'
-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()
-}
-
-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 */
-    (
-      p.length === 1 ||
-      p.charAt(1) === '/' ||
-      (isWindows && p.charAt(1) === '\\') ||
-      (p.charAt(1) === '.' && ((
-        p.length === 2 ||
-        p.charAt(2) === '/') ||
-        (isWindows && p.charAt(2) === '\\')))
-    )
-}
-
-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:') {
-      return url.href
-    } else {
-      return null
-    }
-  } catch {
-    // 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 pathToFileURL(specifier).href
-  }
-
-  /* c8 ignore next 3 */
-  if (!referencingModuleId) {
-    throw new errors.CannotMapSpecifierToAbsolutePathError(specifier)
-  }
-
-  /* c8 ignore next 5 - c8 upgrade marked many existing things as uncovered */
-  if (isRelativePath(specifier)) {
-    return pathToFileURL(
-      pathResolve(dirname(fileURLToPath(referencingModuleId)), specifier)
-    ).href
-  } else {
-    // The specifier is something in node_modules/.
-    const req = createRequire(referencingModuleId)
-
-    return pathToFileURL(req.resolve(specifier)).href
-  }
-}
-
-export async function resolve (specifier, context, nextResolve) {
-  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 url !== 'string' || url === import.meta.url || url.match(/node_modules/)) {
-    return nextResolve(specifier, 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()
-    port.postMessage('plt:cache-cleared')
-  })
-
-  return 'globalThis.LOADER_PORT = port;'
-}
-
-export async function initialize (data) {
-  port = data.port
-  port.on('message', () => {
-    bustEsmCache()
-    port.postMessage('plt:cache-cleared')
-  })
-}

package/lib/message-port-writable.js

@@ -1,50 +0,0 @@
-'use strict'
-const assert = require('node:assert')
-const { Writable } = require('node:stream')
-
-class MessagePortWritable extends Writable {
-  constructor (options) {
-    const opts = { ...options, objectMode: true }
-
-    super(opts)
-    this.port = opts.port
-    this.metadata = opts.metadata
-  }
-
-  _write (chunk, encoding, callback) {
-    this.port.postMessage({
-      metadata: this.metadata,
-      logs: [chunk.toString().trim()]
-    })
-    process.nextTick(callback)
-  }
-
-  _writev (chunks, callback) {
-    // Process the logs here before trying to send them across the thread
-    // boundary. Sometimes the chunks have an undocumented method on them
-    // which will prevent sending the chunk itself across threads.
-    const logs = chunks.map((chunk) => {
-      // pino should always produce a string here.
-      assert(typeof chunk.chunk === 'string')
-      return chunk.chunk.trim()
-    })
-
-    this.port.postMessage({
-      metadata: this.metadata,
-      logs
-    })
-    setImmediate(callback)
-  }
-
-  _final (callback) {
-    this.port.close()
-    callback()
-  }
-
-  _destroy (err, callback) {
-    this.port.close()
-    callback(err)
-  }
-}
-
-module.exports = { MessagePortWritable }

package/lib/worker.js

@@ -1,182 +0,0 @@
-'use strict'
-
-const inspector = require('node:inspector')
-const { register, createRequire } = require('node:module')
-const { isatty } = require('node:tty')
-const { join } = require('node:path')
-const { pathToFileURL } = require('node:url')
-const {
-  MessageChannel,
-  parentPort,
-  workerData
-} = require('node:worker_threads')
-const undici = require('undici')
-const pino = require('pino')
-const pretty = require('pino-pretty')
-const { setGlobalDispatcher, Agent } = require('undici')
-const RuntimeApi = require('./api')
-const { MessagePortWritable } = require('./message-port-writable')
-const loadInterceptors = require('./interceptors')
-let loaderPort
-
-if (typeof register === 'function' && workerData.config.loaderFile) {
-  const { port1, port2 } = new MessageChannel()
-  register(workerData.config.loaderFile, {
-    data: { port: port2 },
-    transferList: [port2]
-  })
-  loaderPort = port1
-} else if (globalThis.LOADER_PORT) {
-  loaderPort = globalThis.LOADER_PORT
-  delete globalThis.LOADER_PORT
-}
-
-globalThis.fetch = undici.fetch
-
-const config = workerData.config
-
-function createLogger (config) {
-  const loggerConfig = { ...config.server?.logger }
-  const cliStream = isatty(1) ? pretty() : pino.destination(1)
-
-  if (!config.loggingPort && !config.managementApi) {
-    return pino(loggerConfig, cliStream)
-  }
-
-  const multiStream = pino.multistream([
-    { stream: cliStream, level: loggerConfig.level || 'info' }
-  ])
-
-  if (loggerConfig.transport) {
-    const transport = pino.transport(loggerConfig.transport)
-    multiStream.add({ level: loggerConfig.level || 'info', stream: transport })
-  }
-  if (config.loggingPort) {
-    const portStream = new MessagePortWritable({
-      metadata: config.loggingMetadata,
-      port: config.loggingPort
-    })
-    multiStream.add({ level: 'trace', stream: portStream })
-  }
-  if (config.managementApi) {
-    const logsFileMb = 5
-    const logsLimitMb = config.managementApi?.logs?.maxSize || 200
-
-    let logsLimitCount = Math.ceil(logsLimitMb / logsFileMb) - 1
-    if (logsLimitCount < 1) {
-      logsLimitCount = 1
-    }
-
-    const logsPath = join(workerData.runtimeLogsDir, 'logs')
-    const pinoRoll = pino.transport({
-      target: 'pino-roll',
-      options: {
-        file: logsPath,
-        mode: 0o600,
-        size: logsFileMb + 'm',
-        mkdir: true,
-        fsync: true,
-        limit: {
-          count: logsLimitCount
-        }
-      }
-    })
-    multiStream.add({ level: 'trace', stream: pinoRoll })
-  }
-  return pino({ level: 'trace' }, multiStream)
-}
-
-const logger = createLogger(config)
-if (config.server) {
-  config.server.logger = logger
-}
-
-let stop
-
-/* c8 ignore next 4 */
-process.on('uncaughtException', (err) => {
-  logger.error({ err }, 'runtime uncaught exception')
-
-  if (stop) {
-    stop().then(() => {
-      setImmediate(process.exit.bind(process), 1)
-    })
-  } else {
-    setImmediate(process.exit.bind(process), 1)
-  }
-})
-
-// Tested by test/cli/start.test.mjs by C8 does not see it.
-/* c8 ignore next 4 */
-process.on('unhandledRejection', (err) => {
-  logger.error({ err }, 'runtime unhandled rejection')
-
-  if (stop) {
-    stop().then(() => {
-      setImmediate(process.exit.bind(process), 1)
-    })
-  } else {
-    setImmediate(process.exit.bind(process), 1)
-  }
-})
-
-async function main () {
-  if (config.preload) {
-    await import(pathToFileURL(config.preload))
-  }
-
-  const { inspectorOptions } = workerData.config
-
-  if (inspectorOptions) {
-    /* c8 ignore next 6 */
-    if (inspectorOptions.hotReloadDisabled) {
-      logger.info('debugging flags were detected. hot reloading has been disabled')
-    }
-
-    inspector.open(inspectorOptions.port, inspectorOptions.host, inspectorOptions.breakFirstLine)
-  }
-
-  const interceptors = {}
-  const composedInterceptors = []
-  if (config.undici?.interceptors) {
-    const _require = createRequire(join(workerData.dirname, 'package.json'))
-    for (const key of ['Agent', 'Pool', 'Client']) {
-      if (config.undici.interceptors[key]) {
-        interceptors[key] = await loadInterceptors(_require, config.undici.interceptors[key])
-      }
-    }
-
-    if (Array.isArray(config.undici.interceptors)) {
-      composedInterceptors.push(...await loadInterceptors(_require, config.undici.interceptors))
-    }
-  }
-
-  const globalDispatcher = new Agent({
-    ...config.undici,
-    interceptors
-  })
-  setGlobalDispatcher(globalDispatcher)
-
-  const runtime = new RuntimeApi(workerData.config, logger, loaderPort, composedInterceptors)
-  runtime.startListening(parentPort)
-
-  parentPort.postMessage('plt:init')
-
-  let stopping = false
-
-  stop = async function () {
-    if (stopping) {
-      return
-    }
-
-    stopping = true
-    try {
-      await runtime.stopServices()
-    } catch (err) {
-      logger.error({ err }, 'error while stopping services')
-    }
-  }
-}
-
-// No need to catch this because there is the unhadledRejection handler on top.
-main()