@platformatic/runtime 3.0.0-alpha.5 → 3.0.0-alpha.8

package/lib/scheduler.js

@@ -1,10 +1,8 @@
-'use strict'
+import { CronJob, validateCronExpression } from 'cron'
+import { setTimeout } from 'node:timers/promises'
+import { request } from 'undici'
 
-const { CronJob, validateCronExpression } = require('cron')
-const { setTimeout } = require('node:timers/promises')
-const { request } = require('undici')
-
-class SchedulerService {
+export class SchedulerService {
   constructor (schedulerConfig, dispatcher, logger) {
     this.logger = logger
     this.jobsConfig = []
@@ -49,7 +47,7 @@ class SchedulerService {
         },
         start: true,
         timeZone: 'UTC',
-        waitForCompletion: true,
+        waitForCompletion: true
       })
 
       this.cronJobs.push(cronJob)
@@ -71,7 +69,9 @@ class SchedulerService {
         const delay = attempt > 0 ? 100 * Math.pow(2, attempt) : 0
 
         if (delay > 0) {
-          this.logger.info(`Retrying scheduler "${scheduler.name}" in ${delay}ms (attempt ${attempt + 1}/${scheduler.maxRetries})`)
+          this.logger.info(
+            `Retrying scheduler "${scheduler.name}" in ${delay}ms (attempt ${attempt + 1}/${scheduler.maxRetries})`
+          )
           await setTimeout(delay)
         }
         const headers = {
@@ -98,7 +98,10 @@ class SchedulerService {
           throw new Error(`HTTP error ${response.statusCode}`)
         }
       } catch (error) {
-        this.logger.error(`Error executing scheduler "${scheduler.name}" (attempt ${attempt + 1}/${scheduler.maxRetries}):`, error.message)
+        this.logger.error(
+          `Error executing scheduler "${scheduler.name}" (attempt ${attempt + 1}/${scheduler.maxRetries}):`,
+          error.message
+        )
         attempt++
       }
     }
@@ -109,13 +112,8 @@ class SchedulerService {
   }
 }
 
-const startScheduler = (config, interceptors, logger) => {
+export function startScheduler (config, interceptors, logger) {
   const schedulerService = new SchedulerService(config, interceptors, logger)
   schedulerService.start()
   return schedulerService
 }
-
-module.exports = {
-  startScheduler,
-  SchedulerService
-}

package/lib/schema.js

@@ -1,9 +1,7 @@
 #! /usr/bin/env node
-'use strict'
 
-const { schemaComponents } = require('@platformatic/foundation')
-
-const pkg = require('../package.json')
+import { schemaComponents } from '@platformatic/foundation'
+import { version } from './version.js'
 
 const runtimeLogger = {
   ...schemaComponents.runtimeProperties.logger,
@@ -19,17 +17,22 @@ const runtimeLogger = {
 schemaComponents.runtimeProperties.logger = runtimeLogger
 
 const platformaticRuntimeSchema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`,
+  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
   title: 'Platformatic Runtime Config',
   type: 'object',
   properties: schemaComponents.runtimeProperties,
-  anyOf: [{ required: ['autoload'] }, { required: ['services'] }, { required: ['web'] }],
+  anyOf: [
+    { required: ['autoload'] },
+    { required: ['applications'] },
+    { required: ['services'] },
+    { required: ['web'] }
+  ],
   additionalProperties: false
 }
 
-module.exports.schema = platformaticRuntimeSchema
+export const schema = platformaticRuntimeSchema
 
-if (require.main === module) {
+if (import.meta.main) {
   console.log(JSON.stringify(platformaticRuntimeSchema, null, 2))
 }

package/lib/shared-http-cache.js

@@ -1,11 +1,9 @@
-'use strict'
+import { loadModule } from '@platformatic/foundation'
+import MemoryCacheStore from '@platformatic/undici-cache-memory'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
 
-const { join } = require('node:path')
-const { loadModule } = require('@platformatic/foundation')
-const MemoryCacheStore = require('@platformatic/undici-cache-memory')
-const { createRequire } = require('node:module')
-
-async function createSharedStore (projectDir, httpCacheConfig = {}) {
+export async function createSharedStore (projectDir, httpCacheConfig = {}) {
   const runtimeRequire = createRequire(join(projectDir, 'file'))
 
   const { store, ...storeConfig } = httpCacheConfig
@@ -43,5 +41,3 @@ async function createSharedStore (projectDir, httpCacheConfig = {}) {
 
   return new SharedCacheStore(storeConfig)
 }
-
-module.exports = { createSharedStore }

package/lib/upgrade.js

@@ -1,13 +1,11 @@
-'use strict'
+import { abstractLogger } from '@platformatic/foundation'
+import { join } from 'node:path'
+import { semgrator } from 'semgrator'
 
-const { abstractLogger } = require('@platformatic/foundation')
-const { join } = require('node:path')
-const { semgrator } = require('semgrator')
-
-async function upgrade (logger, config, version) {
+export async function upgrade (logger, config, version) {
   const iterator = semgrator({
     version,
-    path: join(__dirname, 'versions'),
+    path: join(import.meta.dirname, 'versions'),
     input: config,
     logger: logger?.child({ name: '@platformatic/runtime' }) ?? abstractLogger
   })
@@ -20,5 +18,3 @@ async function upgrade (logger, config, version) {
 
   return result
 }
-
-module.exports = { upgrade }

package/lib/utils.js

@@ -1,27 +1,19 @@
-'use strict'
+import { createHash } from 'node:crypto'
+import { tmpdir } from 'node:os'
+import { join } from 'node:path'
 
-const { createHash } = require('node:crypto')
-const { tmpdir } = require('node:os')
-const { join } = require('node:path')
-
-function getArrayDifference (a, b) {
+export function getArrayDifference (a, b) {
   return a.filter(element => {
     return !b.includes(element)
   })
 }
 
-function getServiceUrl (id) {
+export function getApplicationUrl (id) {
   return `http://${id}.plt.local`
 }
 
-function getRuntimeTmpDir (runtimeDir) {
+export function getRuntimeTmpDir (runtimeDir) {
   const platformaticTmpDir = join(tmpdir(), 'platformatic', 'applications')
   const runtimeDirHash = createHash('md5').update(runtimeDir).digest('hex')
   return join(platformaticTmpDir, runtimeDirHash)
 }
-
-module.exports = {
-  getArrayDifference,
-  getRuntimeTmpDir,
-  getServiceUrl
-}

package/lib/version.js

@@ -0,0 +1,7 @@
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
+
+const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf-8'))
+
+export const name = packageJson.name
+export const version = packageJson.version

package/lib/versions/v1.36.0.js

@@ -1,11 +1,9 @@
-'use strict'
-
-module.exports = {
+export default {
   version: '1.36.0',
   up: function (config) {
     if (config.restartOnError === undefined) {
       config.restartOnError = false
     }
     return config
-  },
+  }
 }

package/lib/versions/v1.5.0.js

@@ -1,11 +1,9 @@
-'use strict'
-
-module.exports = {
+export default {
   version: '1.5.0',
   up: function (config) {
     if (config.watch !== undefined) {
       delete config.watch
     }
     return config
-  },
+  }
 }

package/lib/versions/v2.0.0.js

@@ -1,8 +1,6 @@
-'use strict'
+import { version } from '../version.js'
 
-const pkg = require('../../package.json')
-
-module.exports = {
+export default {
   version: '1.99.0', // This is to account alpha versions as well
   up: function (config) {
     if (config.restartOnError === undefined) {
@@ -16,7 +14,7 @@ module.exports = {
 
     delete config.allowCycles
 
-    config.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`
+    config.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${version}.json`
 
     if (config.server?.logger) {
       config.logger = config.server.logger

package/lib/versions/v3.0.0.js

@@ -0,0 +1,16 @@
+export default {
+  version: '2.99.0',
+  up (config) {
+    if (typeof config.gracefulShutdown?.service === 'number') {
+      config.gracefulShutdown.application = config.gracefulShutdown.service
+      delete config.gracefulShutdown.service
+    }
+
+    if (typeof config.serviceTimeout === 'number') {
+      config.applicationTimeout = config.serviceTimeout
+      delete config.serviceTimeout
+    }
+
+    return config
+  }
+}

package/lib/worker/{app.js → controller.js}

@@ -1,35 +1,30 @@
-'use strict'
-
-const { existsSync } = require('node:fs')
-const { EventEmitter } = require('node:events')
-const { resolve } = require('node:path')
-const {
-  performance: { eventLoopUtilization }
-} = require('node:perf_hooks')
-const { workerData } = require('node:worker_threads')
-const {
+import {
+  ensureLoggableError,
   FileWatcher,
+  kHandledError,
   listRecognizedConfigurationFiles,
-  loadConfigurationModule,
   loadConfiguration,
-  ensureLoggableError
-} = require('@platformatic/foundation')
-const { getGlobalDispatcher, setGlobalDispatcher } = require('undici')
-const debounce = require('debounce')
-const errors = require('../errors')
-const { getServiceUrl } = require('../utils')
-
-function fetchServiceUrl (service, key) {
-  if (service.localServiceEnvVars.has(key)) {
-    return service.localServiceEnvVars.get(key)
-  } else if (!key.endsWith('_URL') || !service.id) {
+  loadConfigurationModule
+} from '@platformatic/foundation'
+import debounce from 'debounce'
+import { EventEmitter } from 'node:events'
+import { existsSync } from 'node:fs'
+import { resolve } from 'node:path'
+import { getActiveResourcesInfo } from 'node:process'
+import { workerData } from 'node:worker_threads'
+import { getGlobalDispatcher, setGlobalDispatcher } from 'undici'
+import { ApplicationAlreadyStartedError, RuntimeNotStartedError } from '../errors.js'
+import { getApplicationUrl } from '../utils.js'
+
+function fetchApplicationUrl (application, key) {
+  if (!key.endsWith('_URL') || !application.id) {
     return null
   }
 
-  return getServiceUrl(service.id)
+  return getApplicationUrl(application.id)
 }
 
-class PlatformaticApp extends EventEmitter {
+export class Controller extends EventEmitter {
   #starting
   #started
   #listening
@@ -51,20 +46,22 @@ class PlatformaticApp extends EventEmitter {
   ) {
     super()
     this.appConfig = appConfig
-    this.serviceId = this.appConfig.id
+    this.applicationId = this.appConfig.id
     this.workerId = workerId
     this.#watch = watch
     this.#starting = false
     this.#started = false
     this.#listening = false
-    this.stackable = null
+    this.capability = null
     this.#fileWatcher = null
-    this.#lastELU = eventLoopUtilization()
+    this.#lastELU = performance.eventLoopUtilization()
 
     this.#context = {
-      serviceId: this.serviceId,
+      controller: this,
+      applicationId: this.applicationId,
       workerId: this.workerId,
       directory: this.appConfig.path,
+      dependencies: this.appConfig.dependencies,
       isEntrypoint: this.appConfig.entrypoint,
       isProduction: this.appConfig.isProduction,
       telemetryConfig,
@@ -73,8 +70,7 @@ class PlatformaticApp extends EventEmitter {
       serverConfig,
       worker: workerData?.worker,
       hasManagementApi: !!hasManagementApi,
-      localServiceEnvVars: this.appConfig.localServiceEnvVars,
-      fetchServiceUrl: fetchServiceUrl.bind(null, appConfig)
+      fetchApplicationUrl: fetchApplicationUrl.bind(null, appConfig)
     }
   }
 
@@ -86,15 +82,12 @@ class PlatformaticApp extends EventEmitter {
 
   async updateContext (context) {
     this.#context = { ...this.#context, ...context }
-    if (this.stackable) {
-      await this.stackable.updateContext(context)
+    if (this.capability) {
+      await this.capability.updateContext(context)
     }
   }
 
-  async getBootstrapDependencies () {
-    return this.stackable.getBootstrapDependencies?.() ?? []
-  }
-
+  // Note: capability's init() is executed within start
   async init () {
     try {
       const appConfig = this.appConfig
@@ -116,25 +109,25 @@ class PlatformaticApp extends EventEmitter {
       if (appConfig.config) {
         // Parse the configuration file the first time to obtain the schema
         const unvalidatedConfig = await loadConfiguration(appConfig.config, null, {
-          onMissingEnv: this.#context.fetchServiceUrl
+          onMissingEnv: this.#context.fetchApplicationUrl
         })
         const pkg = await loadConfigurationModule(appConfig.path, unvalidatedConfig)
-        this.stackable = await pkg.create(appConfig.path, appConfig.config, this.#context)
+        this.capability = await pkg.create(appConfig.path, appConfig.config, this.#context)
         // We could not find a configuration file, we use the bundle @platformatic/basic with the runtime to load it
       } else {
-        const pkg = await loadConfigurationModule(resolve(__dirname, '../..'), {}, '@platformatic/basic')
-        this.stackable = await pkg.create(appConfig.path, {}, this.#context)
+        const pkg = await loadConfigurationModule(resolve(import.meta.dirname, '../..'), {}, '@platformatic/basic')
+        this.capability = await pkg.create(appConfig.path, {}, this.#context)
       }
 
       this.#updateDispatcher()
     } catch (err) {
       if (err.validationErrors) {
         globalThis.platformatic.logger.error(
-          { err: ensureLoggableError(err.validationErrors) },
+          { err: ensureLoggableError(err) },
           'The application threw a validation error.'
         )
 
-        process.exit(1)
+        throw err
       } else {
         this.#logAndThrow(err)
       }
@@ -143,24 +136,31 @@ class PlatformaticApp extends EventEmitter {
 
   async start () {
     if (this.#starting || this.#started) {
-      throw new errors.ApplicationAlreadyStartedError()
+      throw new ApplicationAlreadyStartedError()
     }
 
     this.#starting = true
 
     try {
-      await this.stackable.init?.()
+      await this.capability.init?.()
+      this.emit('init')
     } catch (err) {
       this.#logAndThrow(err)
     }
 
+    this.emit('starting')
+
+    if (this.capability.status === 'stopped') {
+      return
+    }
+
     if (this.#watch) {
-      const watchConfig = await this.stackable.getWatchConfig()
+      const watchConfig = await this.capability.getWatchConfig()
 
       if (watchConfig.enabled !== false) {
         /* c8 ignore next 4 */
         this.#debouncedRestart = debounce(() => {
-          this.stackable.log({ message: 'files changed', level: 'debug' })
+          this.capability.log({ message: 'files changed', level: 'debug' })
           this.emit('changed')
         }, 100) // debounce restart for 100ms
 
@@ -171,32 +171,34 @@ class PlatformaticApp extends EventEmitter {
     const listen = !!this.appConfig.useHttp
 
     try {
-      await this.stackable.start({ listen })
+      await this.capability.start({ listen })
       this.#listening = listen
       /* c8 ignore next 5 */
     } catch (err) {
-      this.stackable.log({ message: err.message, level: 'debug' })
+      this.capability.log({ message: err.message, level: 'debug' })
       this.#starting = false
       throw err
     }
 
     this.#started = true
     this.#starting = false
-    this.emit('start')
+    this.emit('started')
   }
 
-  async stop (force = false) {
+  async stop (force = false, dependents = []) {
     if (!force && (!this.#started || this.#starting)) {
-      throw new errors.ApplicationNotStartedError()
+      throw new RuntimeNotStartedError()
     }
 
+    this.emit('stopping')
     await this.#stopFileWatching()
-    await this.stackable.stop()
+    await this.capability.waitForDependentsStop(dependents)
+    await this.capability.stop()
 
     this.#started = false
     this.#starting = false
     this.#listening = false
-    this.emit('stop')
+    this.emit('stopped')
   }
 
   async listen () {
@@ -205,7 +207,7 @@ class PlatformaticApp extends EventEmitter {
       return
     }
 
-    await this.stackable.start({ listen: true })
+    await this.capability.start({ listen: true })
   }
 
   async getMetrics ({ format }) {
@@ -221,12 +223,13 @@ class PlatformaticApp extends EventEmitter {
         globalThis.platformatic.onHttpStatsSize(url, size || 0)
       }
     }
-    return this.stackable.getMetrics({ format })
+    globalThis.platformatic.onActiveResourcesEventLoop(getActiveResourcesInfo().length)
+    return this.capability.getMetrics({ format })
   }
 
   async getHealth () {
-    const currentELU = eventLoopUtilization()
-    const elu = eventLoopUtilization(currentELU, this.#lastELU).utilization
+    const currentELU = performance.eventLoopUtilization()
+    const elu = performance.eventLoopUtilization(currentELU, this.#lastELU).utilization
     this.#lastELU = currentELU
 
     const { heapUsed, heapTotal } = process.memoryUsage()
@@ -253,7 +256,7 @@ class PlatformaticApp extends EventEmitter {
     fileWatcher.on('update', this.#debouncedRestart)
 
     fileWatcher.startWatching()
-    this.stackable.log({ message: 'start watching files', level: 'debug' })
+    this.capability.log({ message: 'start watching files', level: 'debug' })
     this.#fileWatcher = fileWatcher
   }
 
@@ -261,20 +264,24 @@ class PlatformaticApp extends EventEmitter {
     const watcher = this.#fileWatcher
 
     if (watcher) {
-      this.stackable.log({ message: 'stop watching files', level: 'debug' })
+      this.capability.log({ message: 'stop watching files', level: 'debug' })
       await watcher.stopWatching()
       this.#fileWatcher = null
     }
   }
 
   #logAndThrow (err) {
-    globalThis.platformatic.logger.error({ err: ensureLoggableError(err) }, 'The application threw an error.')
+    globalThis.platformatic.logger.error(
+      { err: ensureLoggableError(err) },
+      err[kHandledError] ? err.message : 'The application threw an error.'
+    )
+
     throw err
   }
 
   #updateDispatcher () {
     const telemetryConfig = this.#context.telemetryConfig
-    const telemetryId = telemetryConfig?.serviceName
+    const telemetryId = telemetryConfig?.applicationName
 
     const interceptor = dispatch => {
       return function InterceptedDispatch (opts, handler) {
@@ -293,5 +300,3 @@ class PlatformaticApp extends EventEmitter {
     setGlobalDispatcher(dispatcher)
   }
 }
-
-module.exports = { PlatformaticApp }

package/lib/worker/http-cache.js

@@ -1,16 +1,14 @@
-'use strict'
-
-const { randomUUID } = require('node:crypto')
-const { Readable, Writable } = require('node:stream')
-const { interceptors } = require('undici')
-const { kITC } = require('./symbols')
+import { randomUUID } from 'node:crypto'
+import { Readable, Writable } from 'node:stream'
+import { interceptors } from 'undici'
+import { kITC } from './symbols.js'
 
 const kCacheIdHeader = Symbol('cacheIdHeader')
 const CACHE_ID_HEADER = 'x-plt-http-cache-id'
 
 const noop = () => {}
 
-class RemoteCacheStore {
+export class RemoteCacheStore {
   #onRequest
   #onCacheHit
   #onCacheMiss
@@ -89,9 +87,10 @@ class RemoteCacheStore {
         } else {
           payload = Buffer.concat(acc)
         }
-        itc.send('setHttpCacheValue', { request: key, response: value, payload })
+        itc
+          .send('setHttpCacheValue', { request: key, response: value, payload })
           .then(() => callback())
-          .catch((err) => callback(err))
+          .catch(err => callback(err))
       }
     })
   }
@@ -116,14 +115,14 @@ class RemoteCacheStore {
   }
 }
 
-const httpCacheInterceptor = (interceptorOpts) => {
+export function httpCacheInterceptor (interceptorOpts) {
   const originalInterceptor = interceptors.cache(interceptorOpts)
 
   // AsyncLocalStorage that contains a client http request span
-  // Exists only when the nodejs stackable telemetry is enabled
+  // Exists only when the nodejs capability telemetry is enabled
   const clientSpansAls = globalThis.platformatic.clientSpansAls
 
-  return (originalDispatch) => {
+  return originalDispatch => {
     const dispatch = (opts, handler) => {
       const originOnResponseStart = handler.onResponseStart.bind(handler)
       handler.onResponseStart = (ac, statusCode, headers, statusMessage) => {
@@ -170,5 +169,3 @@ const httpCacheInterceptor = (interceptorOpts) => {
     }
   }
 }
-
-module.exports = { RemoteCacheStore, httpCacheInterceptor }

package/lib/worker/interceptors.js

@@ -1,16 +1,14 @@
-'use strict'
-
-const { join } = require('node:path')
-const { workerData, parentPort } = require('node:worker_threads')
-const { pathToFileURL } = require('node:url')
-const { createRequire } = require('node:module')
-const { setGlobalDispatcher, Client, Pool, Agent } = require('undici')
-const { wire } = require('undici-thread-interceptor')
-const { createTelemetryThreadInterceptorHooks } = require('@platformatic/telemetry')
-const { RemoteCacheStore, httpCacheInterceptor } = require('./http-cache')
-const { kInterceptors } = require('./symbols')
-
-async function setDispatcher (runtimeConfig) {
+import { createTelemetryThreadInterceptorHooks } from '@platformatic/telemetry'
+import { createRequire } from 'node:module'
+import { join } from 'node:path'
+import { pathToFileURL } from 'node:url'
+import { parentPort, workerData } from 'node:worker_threads'
+import { Agent, Client, Pool, setGlobalDispatcher } from 'undici'
+import { wire } from 'undici-thread-interceptor'
+import { RemoteCacheStore, httpCacheInterceptor } from './http-cache.js'
+import { kInterceptors } from './symbols.js'
+
+export async function setDispatcher (runtimeConfig) {
   const threadDispatcher = createThreadInterceptor(runtimeConfig)
   const threadInterceptor = threadDispatcher.interceptor
 
@@ -34,7 +32,7 @@ async function setDispatcher (runtimeConfig) {
   return { threadDispatcher }
 }
 
-async function updateUndiciInterceptors (undiciConfig) {
+export async function updateUndiciInterceptors (undiciConfig) {
   const updatableInterceptors = globalThis[kInterceptors]
   if (!updatableInterceptors) return
 
@@ -172,8 +170,8 @@ function createThreadInterceptor (runtimeConfig) {
     // with requests for a domain that's never going to exist.
     domain: '.plt.local',
     port: parentPort,
-    timeout: runtimeConfig.serviceTimeout,
-    ...telemetryHooks,
+    timeout: runtimeConfig.applicationTimeout,
+    ...telemetryHooks
   })
   return threadDispatcher
 }
@@ -197,5 +195,3 @@ function createHttpCacheInterceptor (runtimeConfig) {
   })
   return cacheInterceptor
 }
-
-module.exports = { setDispatcher, updateUndiciInterceptors }