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

package/config.d.ts

@@ -10,6 +10,9 @@ export interface PlatformaticBasicConfig {
   runtime?: {
     preload?: string | string[];
     basePath?: string;
+    services?: {
+      [k: string]: unknown;
+    }[];
     workers?: number | string;
     logger?: {
       level: (
@@ -97,7 +100,7 @@ export interface PlatformaticBasicConfig {
     restartOnError?: boolean | number;
     gracefulShutdown?: {
       runtime: number | string;
-      service: number | string;
+      application: number | string;
     };
     health?: {
       enabled?: boolean | string;
@@ -216,11 +219,11 @@ export interface PlatformaticBasicConfig {
     telemetry?: {
       enabled?: boolean | string;
       /**
-       * The name of the service. Defaults to the folder name if not specified.
+       * The name of the application. Defaults to the folder name if not specified.
        */
-      serviceName: string;
+      applicationName: string;
       /**
-       * The version of the service (optional)
+       * The version of the application (optional)
        */
       version?: string;
       /**
@@ -296,7 +299,7 @@ export interface PlatformaticBasicConfig {
       watchDisabled?: boolean;
       [k: string]: unknown;
     };
-    serviceTimeout?: number | string;
+    applicationTimeout?: number | string;
     messagingTimeout?: number | string;
     env?: {
       [k: string]: string;

package/eslint.config.js

@@ -1,5 +1,3 @@
 import neostandard from 'neostandard'
 
-export default neostandard({
-  ignores: ['**/.next'],
-})
+export default neostandard()

package/index.d.ts

@@ -2,14 +2,8 @@ export interface StartOptions {
   listen?: boolean
 }
 
-export interface Dependency {
-  id: string
-  url?: string
-  local: boolean
-}
-
 export type BaseContext = Partial<{
-  serviceId: string
+  applicationId: string
   isEntrypoint: boolean
   isProduction: boolean
   isStandalone: boolean
@@ -18,7 +12,6 @@ export type BaseContext = Partial<{
   metricsConfig: object
   serverConfig: object
   hasManagementApi: boolean
-  localServiceEnvVars: Map<string, string>
 }>
 
 export interface BaseOptions<Context = BaseContext> {
@@ -27,7 +20,7 @@ export interface BaseOptions<Context = BaseContext> {
 
 export declare const schemaOptions: Partial<Record<string, unknown>>
 
-export class BaseStackable<Config = Record<string, any>, Options = BaseOptions> {
+export class BaseCapability<Config = Record<string, any>, Options = BaseOptions> {
   basePath: string
   constructor (
     type: string,
@@ -76,7 +69,6 @@ export class BaseStackable<Config = Record<string, any>, Options = BaseOptions>
     body: object
   }>
   log (options: { message: string; level: string }): Promise<void>
-  getBootstrapDependencies (): Promise<Dependency[]>
   getWatchConfig (): Promise<{
     enabled: boolean
     path: string

package/index.js

@@ -1,4 +1,4 @@
-export * from './lib/base.js'
+export * from './lib/capability.js'
 export * from './lib/config.js'
 export * from './lib/creation.js'
 export * as errors from './lib/errors.js'

package/lib/{base.js → capability.js}

@@ -1,4 +1,11 @@
-import { buildPinoOptions, deepmerge, executeWithTimeout, kMetadata, kTimeout } from '@platformatic/foundation'
+import {
+  buildPinoOptions,
+  deepmerge,
+  executeWithTimeout,
+  kHandledError,
+  kMetadata,
+  kTimeout
+} from '@platformatic/foundation'
 import { client, collectMetrics, ensureMetricsGroup } from '@platformatic/metrics'
 import { parseCommandString } from 'execa'
 import { spawn } from 'node:child_process'
@@ -13,17 +20,45 @@ import { cleanBasePath } from './utils.js'
 import { ChildManager } from './worker/child-manager.js'
 const kITC = Symbol.for('plt.runtime.itc')
 
-export class BaseStackable extends EventEmitter {
-  childManager
-  subprocess
+export class BaseCapability extends EventEmitter {
+  status
+  type
+  version
+  root
+  config
+  context
+  standardStreams
+
+  applicationId
+  workerId
+  telemetryConfig
+  serverConfig
+  openapiSchema
+  graphqlSchema
+  connectionString
+  basePath
+  isEntrypoint
+  isProduction
+  dependencies
+  customHealthCheck
+  customReadinessCheck
+  clientWs
+  runtimeConfig
+  stdout
+  stderr
   subprocessForceClose
   subprocessTerminationSignal
+  logger
+  metricsRegistr
+
   #subprocessStarted
   #metricsCollected
+  #pendingDependenciesWaits
 
   constructor (type, version, root, config, context, standardStreams = {}) {
     super()
 
+    this.status = ''
     this.type = type
     this.version = version
     this.root = root
@@ -32,7 +67,7 @@ export class BaseStackable extends EventEmitter {
     this.context.worker ??= { count: 1, index: 0 }
     this.standardStreams = standardStreams
 
-    this.serviceId = this.context.serviceId
+    this.applicationId = this.context.applicationId
     this.workerId = this.context.worker.count > 1 ? this.context.worker.index : undefined
     this.telemetryConfig = this.context.telemetryConfig
     this.serverConfig = deepmerge(this.context.serverConfig ?? {}, config.server ?? {})
@@ -42,7 +77,7 @@ export class BaseStackable extends EventEmitter {
     this.basePath = null
     this.isEntrypoint = this.context.isEntrypoint
     this.isProduction = this.context.isProduction
-    this.#metricsCollected = false
+    this.dependencies = this.context.dependencies ?? []
     this.customHealthCheck = null
     this.customReadinessCheck = null
     this.clientWs = null
@@ -51,12 +86,12 @@ export class BaseStackable extends EventEmitter {
     this.stderr = standardStreams?.stderr ?? process.stderr
     this.subprocessForceClose = false
     this.subprocessTerminationSignal = 'SIGINT'
-
     this.logger = this._initializeLogger()
 
     // Setup globals
     this.registerGlobals({
-      serviceId: this.serviceId,
+      capability: this,
+      applicationId: this.applicationId,
       workerId: this.workerId,
       logLevel: this.logger.level,
       // Always use URL to avoid serialization problem in Windows
@@ -79,10 +114,25 @@ export class BaseStackable extends EventEmitter {
       this.metricsRegistry = new client.Registry()
       this.registerGlobals({ prometheus: { client, registry: this.metricsRegistry } })
     }
+
+    this.#metricsCollected = false
+    this.#pendingDependenciesWaits = new Set()
   }
 
-  init () {
-    return this.updateContext()
+  async init () {
+    if (this.status) {
+      return
+    }
+
+    // Wait for explicit dependencies to start
+    await this.waitForDependenciesStart(this.dependencies)
+
+    if (this.status === 'stopped') {
+      return
+    }
+
+    await this.updateContext()
+    this.status = 'init'
   }
 
   updateContext (_context) {
@@ -90,11 +140,15 @@ export class BaseStackable extends EventEmitter {
   }
 
   start () {
-    throw new Error('BaseStackable.start must be overriden by the subclasses')
+    throw new Error('BaseCapability.start must be overriden by the subclasses')
   }
 
-  stop () {
-    throw new Error('BaseStackable.stop must be overriden by the subclasses')
+  async stop () {
+    if (this.#pendingDependenciesWaits.size > 0) {
+      await Promise.allSettled(this.#pendingDependenciesWaits)
+    }
+
+    this.status = 'stopped'
   }
 
   build () {
@@ -107,7 +161,107 @@ export class BaseStackable extends EventEmitter {
   }
 
   inject () {
-    throw new Error('BaseStackable.inject must be overriden by the subclasses')
+    throw new Error('BaseCapability.inject must be overriden by the subclasses')
+  }
+
+  async waitForDependenciesStart (dependencies = []) {
+    if (!globalThis[kITC]) {
+      return
+    }
+
+    const pending = new Set(dependencies)
+
+    // Ask the runtime the status of the dependencies and don't wait if they are already started
+    const workers = await globalThis[kITC].send('getWorkers')
+
+    for (const worker of Object.values(workers)) {
+      if (this.dependencies.includes(worker.application) && worker.status === 'started') {
+        pending.delete(worker.application)
+      }
+    }
+
+    if (!pending.size) {
+      return
+    }
+
+    this.logger.info({ dependencies: Array.from(pending) }, 'Waiting for dependencies to start.')
+
+    const { promise, resolve, reject } = Promise.withResolvers()
+
+    function runtimeEventHandler ({ event, payload }) {
+      if (event !== 'application:worker:started') {
+        return
+      }
+
+      pending.delete(payload.application)
+
+      if (pending.size === 0) {
+        cleanupEvents()
+        resolve()
+      }
+    }
+
+    function stopHandler () {
+      cleanupEvents()
+
+      const error = new Error('One of the service dependencies was unable to start.')
+      error.dependencies = dependencies
+      error[kHandledError] = true
+      reject(error)
+    }
+
+    const cleanupEvents = () => {
+      globalThis[kITC].removeListener('runtime:event', runtimeEventHandler)
+      this.context.controller.removeListener('stopping', stopHandler)
+      this.#pendingDependenciesWaits.delete(promise)
+    }
+
+    globalThis[kITC].on('runtime:event', runtimeEventHandler)
+    this.context.controller.on('stopping', stopHandler)
+    this.#pendingDependenciesWaits.add(promise)
+
+    return promise
+  }
+
+  async waitForDependentsStop (dependents = []) {
+    if (!globalThis[kITC]) {
+      return
+    }
+
+    const pending = new Set(dependents)
+
+    // Ask the runtime the status of the dependencies and don't wait if they are already stopped
+    const workers = await globalThis[kITC].send('getWorkers')
+
+    for (const worker of Object.values(workers)) {
+      if (this.dependencies.includes(worker.application) && worker.status === 'started') {
+        pending.delete(worker.application)
+      }
+    }
+
+    if (!pending.size) {
+      return
+    }
+
+    this.logger.info({ dependents: Array.from(pending) }, 'Waiting for dependents to stop.')
+
+    const { promise, resolve } = Promise.withResolvers()
+
+    function runtimeEventHandler ({ event, payload }) {
+      if (event !== 'application:worker:stopped') {
+        return
+      }
+
+      pending.delete(payload.application)
+
+      if (pending.size === 0) {
+        globalThis[kITC].removeListener('runtime:event', runtimeEventHandler)
+        resolve()
+      }
+    }
+
+    globalThis[kITC].on('runtime:event', runtimeEventHandler)
+    return promise
   }
 
   getUrl () {
@@ -145,7 +299,7 @@ export class BaseStackable extends EventEmitter {
   }
 
   async getInfo () {
-    return { type: this.type, version: this.version }
+    return { type: this.type, version: this.version, dependencies: this.dependencies }
   }
 
   getDispatchFunc () {
@@ -158,7 +312,7 @@ export class BaseStackable extends EventEmitter {
 
   getMeta () {
     return {
-      composer: {
+      gateway: {
         wantsAbsoluteUrls: false
       }
     }
@@ -338,7 +492,7 @@ export class BaseStackable extends EventEmitter {
   }
 
   async stopCommand () {
-    const exitTimeout = this.runtimeConfig.gracefulShutdown.service
+    const exitTimeout = this.runtimeConfig.gracefulShutdown.application
 
     this.#subprocessStarted = false
     const exitPromise = once(this.subprocess, 'exit')
@@ -380,7 +534,7 @@ export class BaseStackable extends EventEmitter {
     return {
       id: this.id,
       config: this.config,
-      serviceId: this.serviceId,
+      applicationId: this.applicationId,
       workerId: this.workerId,
       // Always use URL to avoid serialization problem in Windows
       root: pathToFileURL(this.root).toString(),
@@ -388,7 +542,7 @@ export class BaseStackable extends EventEmitter {
       logLevel: this.logger.level,
       isEntrypoint: this.isEntrypoint,
       runtimeBasePath: this.runtimeConfig?.basePath ?? null,
-      wantsAbsoluteUrls: meta.composer?.wantsAbsoluteUrls ?? false,
+      wantsAbsoluteUrls: meta.gateway?.wantsAbsoluteUrls ?? false,
       /* c8 ignore next 2 - else */
       port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
       host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
@@ -430,7 +584,7 @@ export class BaseStackable extends EventEmitter {
     const pinoOptions = buildPinoOptions(
       loggerOptions,
       this.serverConfig?.logger,
-      this.serviceId,
+      this.applicationId,
       this.workerId,
       this.context,
       this.root
@@ -463,14 +617,14 @@ export class BaseStackable extends EventEmitter {
 
     if (this.childManager && this.clientWs) {
       await this.childManager.send(this.clientWs, 'collectMetrics', {
-        serviceId: this.serviceId,
+        applicationId: this.applicationId,
         workerId: this.workerId,
         metricsConfig
       })
       return
     }
 
-    await collectMetrics(this.serviceId, this.workerId, metricsConfig, this.metricsRegistry)
+    await collectMetrics(this.applicationId, this.workerId, metricsConfig, this.metricsRegistry)
   }
 
   #setHttpCacheMetrics () {
@@ -559,6 +713,13 @@ export class BaseStackable extends EventEmitter {
     globalThis.platformatic.onHttpStatsSize = (url, val) => {
       httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
     }
+
+    const activeResourcesEventLoopMetric = new client.Gauge({
+      name: 'active_resources_event_loop',
+      help: 'Number of active resources keeping the event loop alive',
+      registers: [registry]
+    })
+    globalThis.platformatic.onActiveResourcesEventLoop = (val) => activeResourcesEventLoopMetric.set(val)
   }
 
   async #invalidateHttpCache (opts = {}) {

package/lib/config.js

@@ -54,7 +54,7 @@ export async function resolve (fileOrDirectory, sourceOrConfig, suffixes) {
 }
 
 export async function transform (config) {
-  const patch = workerData?.serviceConfig?.configPatch
+  const patch = workerData?.applicationConfig?.configPatch
 
   if (!config) {
     return config

package/lib/creation.js

@@ -1,9 +1,9 @@
 import { resolve } from './config.js'
-import { importStackableAndConfig } from './modules.js'
+import { importCapabilityAndConfig } from './modules.js'
 
 export async function create (fileOrDirectory, sourceOrConfig, context) {
   const { root, source } = await resolve(fileOrDirectory, sourceOrConfig)
-  const { stackable } = await importStackableAndConfig(root, source, context)
+  const { capability } = await importCapabilityAndConfig(root, source, context)
 
-  return stackable.create(root, source, context)
+  return capability.create(root, source, context)
 }

package/lib/errors.js

@@ -1,6 +1,6 @@
 import createError from '@fastify/error'
 
-const ERROR_PREFIX = 'PLT_BASIC'
+export const ERROR_PREFIX = 'PLT_BASIC'
 
 export const exitCodes = {
   MANAGER_MESSAGE_HANDLING_FAILED: 11,

package/lib/modules.js

@@ -7,7 +7,7 @@ import pino from 'pino'
 import { packageJson } from './schema.js'
 import { importFile } from './utils.js'
 
-const importStackablePackageMarker = '__pltImportStackablePackage.js'
+const importCapabilityPackageMarker = '__pltImportCapabilityPackage.js'
 
 export function isImportFailedError (error, pkg) {
   if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND') {
@@ -16,10 +16,10 @@ export function isImportFailedError (error, pkg) {
 
   const match = error.message.match(/Cannot find package '(.+)' imported from (.+)/)
 
-  return match?.[1] === pkg || error.requireStack?.[0].endsWith(importStackablePackageMarker)
+  return match?.[1] === pkg || error.requireStack?.[0].endsWith(importCapabilityPackageMarker)
 }
 
-export async function importStackablePackage (directory, pkg) {
+export async function importCapabilityPackage (directory, pkg) {
   let imported
   try {
     try {
@@ -30,8 +30,8 @@ export async function importStackablePackage (directory, pkg) {
         throw e
       }
 
-      // Scope to the service
-      const require = createRequire(resolve(directory, importStackablePackageMarker))
+      // Scope to the application
+      const require = createRequire(resolve(directory, importCapabilityPackageMarker))
       const toImport = require.resolve(pkg)
       imported = await importFile(toImport)
     }
@@ -40,16 +40,16 @@ export async function importStackablePackage (directory, pkg) {
       throw e
     }
 
-    const serviceDirectory = workerData ? relative(workerData.dirname, directory) : directory
+    const applicationDirectory = workerData ? relative(workerData.dirname, directory) : directory
     throw new Error(
-      `Unable to import package '${pkg}'. Please add it as a dependency in the package.json file in the folder ${serviceDirectory}.`
+      `Unable to import package '${pkg}'. Please add it as a dependency in the package.json file in the folder ${applicationDirectory}.`
     )
   }
 
   return imported.default ?? imported
 }
 
-export async function importStackableAndConfig (root, config, context) {
+export async function importCapabilityAndConfig (root, config, context) {
   let rootPackageJson
   try {
     rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
@@ -72,27 +72,27 @@ export async function importStackableAndConfig (root, config, context) {
   const { label, name: moduleName } = appType
 
   if (context) {
-    const serviceRoot = relative(process.cwd(), root)
+    const applicationRoot = relative(process.cwd(), root)
 
-    if (!hadConfig && context.serviceId && !(await findConfigurationFile(root)) && context.worker?.index === 0) {
+    if (!hadConfig && context.applicationId && !(await findConfigurationFile(root)) && context.worker?.index === 0) {
       const autodetectDescription =
         moduleName === '@platformatic/node' ? 'is a generic Node.js application' : `is using ${label}`
 
-      const logger = pino({ level: context.serverConfig?.logger?.level ?? 'warn', name: context.serviceId })
+      const logger = pino({ level: context.serverConfig?.logger?.level ?? 'warn', name: context.applicationId })
 
-      logger.warn(`We have auto-detected that service "${context.serviceId}" ${autodetectDescription}.`)
+      logger.warn(`We have auto-detected that application "${context.applicationId}" ${autodetectDescription}.`)
       logger.warn(
-        `We suggest you create a watt.json or a platformatic.json file in the folder ${serviceRoot} with the "$schema" property set to "https://schemas.platformatic.dev/${moduleName}/${packageJson.version}.json".`
+        `We suggest you create a watt.json or a platformatic.json file in the folder ${applicationRoot} with the "$schema" property set to "https://schemas.platformatic.dev/${moduleName}/${packageJson.version}.json".`
       )
-      logger.warn(`Also don't forget to add "${moduleName}" to the service dependencies.`)
+      logger.warn(`Also don't forget to add "${moduleName}" to the application dependencies.`)
       logger.warn('You can also run "wattpm import" to do this automatically.\n')
     }
   }
 
-  const stackable = await importStackablePackage(root, moduleName)
+  const capability = await importCapabilityPackage(root, moduleName)
 
   return {
-    stackable,
+    capability,
     config,
     autodetectDescription:
       moduleName === '@platformatic/node' ? 'is a generic Node.js application' : `is using ${label}`,

package/lib/schema.js

@@ -44,7 +44,7 @@ const buildableApplication = {
           default: 'npm ci --omit-dev'
         },
         // All the following options purposely don't have a default so
-        // that stackables can detect if the user explicitly set them.
+        // that capabilities can detect if the user explicitly set them.
         build: {
           type: 'string'
         },

package/lib/worker/child-manager.js

@@ -1,5 +1,5 @@
 import { createDirectory, ensureLoggableError } from '@platformatic/foundation'
-import { ITC } from '@platformatic/itc'
+import { ITC } from '@platformatic/itc/lib/index.js'
 import { once } from 'node:events'
 import { rm, writeFile } from 'node:fs/promises'
 import { createServer } from 'node:http'
@@ -137,7 +137,7 @@ export class ChildManager extends ITC {
   async inject () {
     await this.listen()
 
-    // Serialize data into a JSON file for the stackable to use
+    // Serialize data into a JSON file for the capability to use
     this.#dataPath = resolve(tmpdir(), 'platformatic', 'runtimes', `${this.#id}.json`)
     await createDirectory(dirname(this.#dataPath))
 

package/lib/worker/child-process.js

@@ -5,7 +5,7 @@ import {
   ensureLoggableError,
   features
 } from '@platformatic/foundation'
-import { ITC } from '@platformatic/itc'
+import { ITC } from '@platformatic/itc/lib/index.js'
 import { client, collectMetrics } from '@platformatic/metrics'
 import diagnosticChannel, { tracingChannel } from 'node:diagnostics_channel'
 import { EventEmitter, once } from 'node:events'
@@ -196,8 +196,8 @@ export class ChildProcess extends ITC {
     this.#socket.close()
   }
 
-  async #collectMetrics ({ serviceId, workerId, metricsConfig }) {
-    await collectMetrics(serviceId, workerId, metricsConfig, this.#metricsRegistry)
+  async #collectMetrics ({ applicationId, workerId, metricsConfig }) {
+    await collectMetrics(applicationId, workerId, metricsConfig, this.#metricsRegistry)
     this.#setHttpCacheMetrics()
   }
 
@@ -282,6 +282,13 @@ export class ChildProcess extends ITC {
     globalThis.platformatic.onHttpStatsSize = (url, val) => {
       httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
     }
+
+    const activeResourcesEventLoopMetric = new client.Gauge({
+      name: 'active_resources_event_loop',
+      help: 'Number of active resources keeping the event loop alive',
+      registers: [registry]
+    })
+    globalThis.platformatic.onActiveResourcesEventLoop = (val) => activeResourcesEventLoopMetric.set(val)
   }
 
   async #getMetrics ({ format } = {}) {
@@ -295,12 +302,12 @@ export class ChildProcess extends ITC {
     disablePinoDirectWrite()
 
     // Since this is executed by user code, make sure we only override this in the main thread
-    // The rest will be intercepted by the BaseStackable.
+    // The rest will be intercepted by the BaseCapability.
     const loggerOptions = globalThis.platformatic?.config?.logger ?? {}
     const pinoOptions = {
       ...loggerOptions,
       level: loggerOptions.level ?? 'info',
-      name: globalThis.platformatic.serviceId
+      name: globalThis.platformatic.applicationId
     }
     if (loggerOptions.formatters) {
       pinoOptions.formatters = buildPinoFormatters(loggerOptions.formatters)
@@ -385,8 +392,8 @@ export class ChildProcess extends ITC {
   #setupHandlers () {
     const errorLabel =
       typeof globalThis.platformatic.workerId !== 'undefined'
-        ? `worker ${globalThis.platformatic.workerId} of the service "${globalThis.platformatic.serviceId}"`
-        : `service "${globalThis.platformatic.serviceId}"`
+        ? `worker ${globalThis.platformatic.workerId} of the application "${globalThis.platformatic.applicationId}"`
+        : `application "${globalThis.platformatic.applicationId}"`
 
     function handleUnhandled (type, err) {
       this.#logger.error({ err: ensureLoggableError(err) }, `Child process for the ${errorLabel} threw an ${type}.`)

package/lib/worker/child-transport.js

@@ -1,5 +1,5 @@
 import { ensureLoggableError } from '@platformatic/foundation'
-import { generateRequest, sanitize } from '@platformatic/itc'
+import { generateRequest, sanitize } from '@platformatic/itc/lib/index.js'
 import { once } from 'node:events'
 import { platform } from 'node:os'
 import { workerData } from 'node:worker_threads'
@@ -9,7 +9,7 @@ import { getSocketPath } from './child-manager.js'
 
 /* c8 ignore next 5 */
 function logDirectError (message, error) {
-  process._rawDebug(`Logger thread for child process of service ${workerData.id} ${message}.`, {
+  process._rawDebug(`Logger thread for child process of application ${workerData.id} ${message}.`, {
     error: ensureLoggableError(error)
   })
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "3.0.0-alpha.5",
+  "version": "3.0.0-alpha.8",
   "description": "",
   "main": "index.js",
   "types": "index.d.ts",
@@ -25,13 +25,13 @@
     "split2": "^4.2.0",
     "undici": "^7.0.0",
     "ws": "^8.18.0",
-    "@platformatic/itc": "3.0.0-alpha.5",
-    "@platformatic/metrics": "3.0.0-alpha.5",
-    "@platformatic/foundation": "3.0.0-alpha.5",
-    "@platformatic/telemetry": "3.0.0-alpha.5"
+    "@platformatic/itc": "3.0.0-alpha.8",
+    "@platformatic/foundation": "3.0.0-alpha.8",
+    "@platformatic/telemetry": "3.0.0-alpha.8",
+    "@platformatic/metrics": "3.0.0-alpha.8"
   },
   "devDependencies": {
-    "borp": "^0.20.0",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
     "express": "^4.19.2",
     "fastify": "^5.0.0",
@@ -44,11 +44,10 @@
     "node": ">=22.18.0"
   },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --timeout 1200000",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout 1200000",
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
     "gen-schema": "node lib/schema.js > schema.json",
     "gen-types": "json2ts > config.d.ts < schema.json",
-    "build": "pnpm run gen-schema && pnpm run gen-types",
+    "build": "npm run gen-schema && npm run gen-types",
     "lint": "eslint"
   }
 }

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/3.0.0-alpha.5.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/3.0.0-alpha.8.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Basic Config",
   "type": "object",
@@ -28,6 +28,242 @@
         "basePath": {
           "type": "string"
         },
+        "services": {
+          "type": "array",
+          "items": {
+            "type": "object",
+            "anyOf": [
+              {
+                "required": [
+                  "id",
+                  "path"
+                ]
+              },
+              {
+                "required": [
+                  "id",
+                  "url"
+                ]
+              }
+            ],
+            "properties": {
+              "id": {
+                "type": "string"
+              },
+              "path": {
+                "type": "string",
+                "allowEmptyPaths": true,
+                "resolvePath": true
+              },
+              "config": {
+                "type": "string"
+              },
+              "url": {
+                "type": "string"
+              },
+              "gitBranch": {
+                "type": "string",
+                "default": "main"
+              },
+              "useHttp": {
+                "type": "boolean"
+              },
+              "workers": {
+                "anyOf": [
+                  {
+                    "type": "number",
+                    "minimum": 1
+                  },
+                  {
+                    "type": "string"
+                  }
+                ]
+              },
+              "health": {
+                "type": "object",
+                "default": {},
+                "properties": {
+                  "enabled": {
+                    "anyOf": [
+                      {
+                        "type": "boolean"
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "interval": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "gracePeriod": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "maxUnhealthyChecks": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 1
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "maxELU": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "maxHeapUsed": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0,
+                        "maximum": 1
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "maxHeapTotal": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  },
+                  "maxYoungGeneration": {
+                    "anyOf": [
+                      {
+                        "type": "number",
+                        "minimum": 0
+                      },
+                      {
+                        "type": "string"
+                      }
+                    ]
+                  }
+                },
+                "additionalProperties": false
+              },
+              "dependencies": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                },
+                "default": []
+              },
+              "arguments": {
+                "type": "array",
+                "items": {
+                  "type": "string"
+                }
+              },
+              "env": {
+                "type": "object",
+                "additionalProperties": {
+                  "type": "string"
+                }
+              },
+              "envfile": {
+                "type": "string"
+              },
+              "sourceMaps": {
+                "type": "boolean",
+                "default": false
+              },
+              "packageManager": {
+                "type": "string",
+                "enum": [
+                  "npm",
+                  "pnpm",
+                  "yarn"
+                ]
+              },
+              "preload": {
+                "anyOf": [
+                  {
+                    "type": "string",
+                    "resolvePath": true
+                  },
+                  {
+                    "type": "array",
+                    "items": {
+                      "type": "string",
+                      "resolvePath": true
+                    }
+                  }
+                ]
+              },
+              "nodeOptions": {
+                "type": "string"
+              },
+              "telemetry": {
+                "type": "object",
+                "properties": {
+                  "instrumentations": {
+                    "type": "array",
+                    "description": "An array of instrumentations loaded if telemetry is enabled",
+                    "items": {
+                      "oneOf": [
+                        {
+                          "type": "string"
+                        },
+                        {
+                          "type": "object",
+                          "properties": {
+                            "package": {
+                              "type": "string"
+                            },
+                            "exportName": {
+                              "type": "string"
+                            },
+                            "options": {
+                              "type": "object",
+                              "additionalProperties": true
+                            }
+                          },
+                          "required": [
+                            "package"
+                          ]
+                        }
+                      ]
+                    }
+                  }
+                }
+              }
+            }
+          }
+        },
         "workers": {
           "anyOf": [
             {
@@ -342,7 +578,7 @@
               ],
               "default": 10000
             },
-            "service": {
+            "application": {
               "anyOf": [
                 {
                   "type": "number",
@@ -358,7 +594,7 @@
           "default": {},
           "required": [
             "runtime",
-            "service"
+            "application"
           ],
           "additionalProperties": false
         },
@@ -789,13 +1025,13 @@
                 }
               ]
             },
-            "serviceName": {
+            "applicationName": {
               "type": "string",
-              "description": "The name of the service. Defaults to the folder name if not specified."
+              "description": "The name of the application. Defaults to the folder name if not specified."
             },
             "version": {
               "type": "string",
-              "description": "The version of the service (optional)"
+              "description": "The version of the application (optional)"
             },
             "skip": {
               "type": "array",
@@ -902,7 +1138,7 @@
             }
           },
           "required": [
-            "serviceName"
+            "applicationName"
           ],
           "additionalProperties": false
         },
@@ -923,7 +1159,7 @@
             }
           }
         },
-        "serviceTimeout": {
+        "applicationTimeout": {
           "anyOf": [
             {
               "type": "number",