@platformatic/runtime 2.0.0-alpha.2 → 2.0.0-alpha.4

package/lib/app.js

@@ -1,397 +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 { snakeCase } = require('change-case-all')
-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 () {
-    if (this.#starting || !this.#started) {
-      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 getBootstrapDependencies () {
-    await this.#loadConfig()
-    const resolver = this.config.app.getBootstrapDependencies
-    if (typeof resolver === 'function') {
-      return resolver(this.appConfig, this.config.configManager)
-    }
-    return []
-  }
-
-  async start () {
-    if (this.#starting || this.#started) {
-      throw new errors.ApplicationAlreadyStartedError()
-    }
-
-    this.#starting = true
-
-    await this.#applyConfig()
-    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) &&
-      this.#originalWatch?.enabled !== false
-    ) {
-      this.#startFileWatching()
-    }
-
-    if (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 listen () {
-    // This server is not an entrypoint or already listened in start. Behave as no-op.
-    if (!this.appConfig.entrypoint || this.appConfig.useHttp) {
-      return
-    }
-
-    await this.server.start()
-  }
-
-  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 #loadConfig () {
-    const appConfig = this.appConfig
-
-    let _config
-    try {
-      _config = await loadConfig({}, ['-c', appConfig.config], {
-        onMissingEnv: this.#fetchServiceUrl,
-        context: appConfig
-      }, true, this.#logger)
-    } catch (err) {
-      this.#logAndExit(err)
-    }
-
-    this.config = _config
-  }
-
-  async #applyConfig () {
-    if (!this.config) {
-      await this.#loadConfig()
-    }
-
-    const appConfig = this.appConfig
-    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
-    ) {
-      configManager.update({
-        ...configManager.current,
-        metrics: {
-          server: 'hide',
-          defaultMetrics: { enabled: this.appConfig.entrypoint },
-          prefix: snakeCase(this.appConfig.id) + '_',
-          ...configManager.current.metrics
-        }
-      })
-    }
-
-    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
-  }
-
-  #fetchServiceUrl (key, { parent, context: service }) {
-    if (service.localServiceEnvVars.has(key)) {
-      return service.localServiceEnvVars.get(key)
-    } else if (!key.endsWith('_URL') || !parent.serviceId) {
-      return null
-    }
-
-    return getServiceUrl(parent.serviceId)
-  }
-
-  #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]
-    }
-  })
-}
-
-function getServiceUrl (id) {
-  return `http://${id}.plt.local`
-}
-
-module.exports = { PlatformaticApp }

package/lib/load-config.js

@@ -1,12 +0,0 @@
-'use strict'
-
-const { Store, loadConfig } = require('@platformatic/config')
-const { platformaticRuntime } = require('./config')
-
-function _loadConfig (minimistConfig, args, overrides, replaceEnv = true) {
-  const store = new Store()
-  store.add(platformaticRuntime)
-  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 }