@platformatic/basic 2.74.3 → 3.0.0-alpha.2

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticStackable {
+export interface PlatformaticBasicConfig {
   $schema?: string;
   runtime?: {
     preload?: string | string[];

package/index.d.ts

@@ -0,0 +1,89 @@
+export interface StartOptions {
+  listen?: boolean
+}
+
+export interface Dependency {
+  id: string
+  url?: string
+  local: boolean
+}
+
+export type BaseContext = Partial<{
+  serviceId: string
+  isEntrypoint: boolean
+  isProduction: boolean
+  isStandalone: boolean
+  directory: string
+  telemetryConfig: object
+  metricsConfig: object
+  serverConfig: object
+  hasManagementApi: boolean
+  localServiceEnvVars: Map<string, string>
+}>
+
+export interface BaseOptions<Context = BaseContext> {
+  context: Context
+}
+
+export declare const schemaOptions: Partial<Record<string, unknown>>
+
+export class BaseStackable<Config = Record<string, any>, Options = BaseOptions> {
+  basePath: string
+  constructor (
+    type: string,
+    version: string,
+    root: string,
+    config: object,
+    standardStreams?: Record<string, NodeJS.WritableStream>
+  )
+
+  init (): Promise<void>
+  start (options: StartOptions): Promise<void>
+  stop (): Promise<void>
+  build (): Promise<void>
+  getUrl (): string
+  updateContext (context: Partial<BaseContext>): Promise<void>
+  getConfig (includeMeta?: boolean): Promise<object>
+  getInfo (): Promise<{ type: string; version: string }>
+  getDispatchFunc (): Promise<Function>
+  getDispatchTarget (): Promise<Function | string>
+  getOpenapiSchema (): Promise<object>
+  getGraphqlSchema (): Promise<string>
+  setConnectionStatus (status: string): Promise<void>
+  setOpenapiSchema (schema: object): Promise<void>
+  setGraphqlSchema (schema: string): Promise<void>
+  setCustomHealthCheck (
+    healthCheck: () =>
+      | boolean
+      | Promise<boolean>
+      | { status: boolean; statusCode?: number; body?: string }
+      | Promise<{ status: boolean; statusCode?: number; body?: string }>
+  ): Promise<void>
+  setCustomReadinessCheck (
+    readinessCheck: () =>
+      | boolean
+      | Promise<boolean>
+      | { status: boolean; statusCode?: number; body?: string }
+      | Promise<{ status: boolean; statusCode?: number; body?: string }>
+  ): Promise<void>
+  collectMetrics (): Promise<any>
+  getMetrics ({ format: string }): Promise<string | Array<object>>
+  getMeta (): Promise<object>
+  inject (injectParams: string | object): Promise<{
+    statusCode: number
+    statusMessage: string
+    headers: object
+    body: object
+  }>
+  log (options: { message: string; level: string }): Promise<void>
+  getBootstrapDependencies (): Promise<Dependency[]>
+  getWatchConfig (): Promise<{
+    enabled: boolean
+    path: string
+    allow?: string[]
+    ignore?: string[]
+  }>
+
+  _initializeLogger (options: object): Promise<void>
+  _collectMetrics (): Promise<void>
+}

package/index.js

@@ -1,145 +1,8 @@
-import { ConfigManager } from '@platformatic/config'
-import { detectApplicationType } from '@platformatic/utils'
-import jsonPatch from 'fast-json-patch'
-import { readFile } from 'node:fs/promises'
-import { createRequire } from 'node:module'
-import { relative, resolve } from 'node:path'
-import { workerData } from 'node:worker_threads'
-import pino from 'pino'
-import { packageJson, schema } from './lib/schema.js'
-import { importFile } from './lib/utils.js'
-
-const importStackablePackageMarker = '__pltImportStackablePackage.js'
-
-function isImportFailedError (error, pkg) {
-  if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND') {
-    return false
-  }
-
-  const match = error.message.match(/Cannot find package '(.+)' imported from (.+)/)
-
-  return match?.[1] === pkg || error.requireStack?.[0].endsWith(importStackablePackageMarker)
-}
-
-async function importStackablePackage (directory, pkg) {
-  try {
-    try {
-      // Try regular import
-      return await import(pkg)
-    } catch (e) {
-      if (!isImportFailedError(e, pkg)) {
-        throw e
-      }
-
-      // Scope to the service
-      const require = createRequire(resolve(directory, importStackablePackageMarker))
-      const imported = require.resolve(pkg)
-      return await importFile(imported)
-    }
-  } catch (e) {
-    if (!isImportFailedError(e, pkg)) {
-      throw e
-    }
-
-    const serviceDirectory = 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}.`
-    )
-  }
-}
-
-export async function importStackableAndConfig (root, config, context) {
-  let rootPackageJson
-  try {
-    rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
-  } catch {
-    rootPackageJson = {}
-  }
-
-  const hadConfig = !!config
-
-  if (!config) {
-    config = await ConfigManager.findConfigFile(root, 'application')
-  }
-
-  const appType = await detectApplicationType(root, rootPackageJson)
-
-  if (!appType) {
-    throw new Error(`Unable to detect application type in ${root}.`)
-  }
-
-  const { label, name: moduleName } = appType
-
-  if (context) {
-    const serviceRoot = relative(process.cwd(), root)
-
-    if (!hadConfig && context.serviceId && !(await ConfigManager.findConfigFile(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 })
-
-      logger.warn(`We have auto-detected that service "${context.serviceId}" ${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".`
-      )
-      logger.warn(`Also don't forget to add "${moduleName}" to the service dependencies.`)
-      logger.warn('You can also run "wattpm import" to do this automatically.\n')
-    }
-  }
-
-  const stackable = await importStackablePackage(root, moduleName)
-
-  return {
-    stackable,
-    config,
-    autodetectDescription:
-      moduleName === '@platformatic/node' ? 'is a generic Node.js application' : `is using ${label}`,
-    moduleName
-  }
-}
-
-async function buildStackable (opts) {
-  const hadConfig = !!opts.config
-  const { stackable, config } = await importStackableAndConfig(opts.context.directory, opts.config, opts.context)
-  opts.config = config
-
-  if (!hadConfig && typeof stackable.createDefaultConfig === 'function') {
-    opts.config = await stackable.createDefaultConfig?.(opts)
-  }
-
-  return stackable.buildStackable(opts)
-}
-
-/* c8 ignore next 3 */
-export async function transformConfig () {
-  const patch = workerData?.serviceConfig?.configPatch
-
-  if (Array.isArray(patch)) {
-    this.current = jsonPatch.applyPatch(this.current, patch).newDocument
-  }
-}
-
-export const schemaOptions = {
-  useDefaults: true,
-  coerceTypes: true,
-  allErrors: true,
-  strict: false
-}
-
-export default {
-  configType: 'nodejs',
-  configManagerConfig: {
-    schemaOptions,
-    transformConfig
-  },
-  buildStackable,
-  schema,
-  version: packageJson.version
-}
-
 export * from './lib/base.js'
+export * from './lib/config.js'
+export * from './lib/creation.js'
 export * as errors from './lib/errors.js'
+export * from './lib/modules.js'
 export { schema, schemaComponents } from './lib/schema.js'
 export * from './lib/utils.js'
 export * from './lib/worker/child-manager.js'

package/lib/base.js

@@ -1,5 +1,5 @@
-import { client, collectMetrics } from '@platformatic/metrics'
-import { buildPinoOptions, deepmerge, executeWithTimeout, kTimeout } from '@platformatic/utils'
+import { buildPinoOptions, deepmerge, executeWithTimeout, kMetadata, kTimeout } from '@platformatic/foundation'
+import { client, collectMetrics, ensureMetricsGroup } from '@platformatic/metrics'
 import { parseCommandString } from 'execa'
 import { spawn } from 'node:child_process'
 import EventEmitter, { once } from 'node:events'
@@ -11,7 +11,6 @@ import pino from 'pino'
 import { NonZeroExitCode } from './errors.js'
 import { cleanBasePath } from './utils.js'
 import { ChildManager } from './worker/child-manager.js'
-
 const kITC = Symbol.for('plt.runtime.itc')
 
 export class BaseStackable extends EventEmitter {
@@ -22,47 +21,38 @@ export class BaseStackable extends EventEmitter {
   #subprocessStarted
   #metricsCollected
 
-  constructor (type, version, options, root, configManager, standardStreams = {}) {
+  constructor (type, version, root, config, context, standardStreams = {}) {
     super()
 
-    options.context.worker ??= { count: 1, index: 0 }
-
     this.type = type
     this.version = version
-    this.serviceId = options.context.serviceId
-    this.workerId = options.context.worker.count > 1 ? options.context.worker.index : undefined
-    this.telemetryConfig = options.context.telemetryConfig
-    this.options = options
     this.root = root
-    this.configManager = configManager
-    this.serverConfig = deepmerge(options.context.serverConfig ?? {}, configManager.current.server ?? {})
+    this.config = config
+    this.context = context ?? {}
+    this.context.worker ??= { count: 1, index: 0 }
+    this.standardStreams = standardStreams
+
+    this.serviceId = this.context.serviceId
+    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 ?? {})
     this.openapiSchema = null
     this.graphqlSchema = null
     this.connectionString = null
     this.basePath = null
-    this.isEntrypoint = options.context.isEntrypoint
-    this.isProduction = options.context.isProduction
-    this.metricsRegistry = new client.Registry()
+    this.isEntrypoint = this.context.isEntrypoint
+    this.isProduction = this.context.isProduction
     this.#metricsCollected = false
     this.customHealthCheck = null
     this.customReadinessCheck = null
     this.clientWs = null
-    this.runtimeConfig = deepmerge(options.context?.runtimeConfig ?? {}, workerData?.config ?? {})
+    this.runtimeConfig = deepmerge(this.context?.runtimeConfig ?? {}, workerData?.config ?? {})
     this.stdout = standardStreams?.stdout ?? process.stdout
     this.stderr = standardStreams?.stderr ?? process.stderr
     this.subprocessForceClose = false
     this.subprocessTerminationSignal = 'SIGINT'
 
-    const loggerOptions = deepmerge(this.runtimeConfig?.logger ?? {}, this.configManager.current?.logger ?? {})
-    const pinoOptions = buildPinoOptions(
-      loggerOptions,
-      this.serverConfig?.logger,
-      this.serviceId,
-      this.workerId,
-      options,
-      this.root
-    )
-    this.logger = pino(pinoOptions, standardStreams?.stdout)
+    this.logger = this._initializeLogger()
 
     // Setup globals
     this.registerGlobals({
@@ -77,28 +67,68 @@ export class BaseStackable extends EventEmitter {
       setBasePath: this.setBasePath.bind(this),
       runtimeBasePath: this.runtimeConfig?.basePath ?? null,
       invalidateHttpCache: this.#invalidateHttpCache.bind(this),
-      prometheus: { client, registry: this.metricsRegistry },
       setCustomHealthCheck: this.setCustomHealthCheck.bind(this),
       setCustomReadinessCheck: this.setCustomReadinessCheck.bind(this),
       notifyConfig: this.notifyConfig.bind(this),
       logger: this.logger
     })
+
+    if (globalThis.platformatic.prometheus) {
+      this.metricsRegistry = globalThis.platformatic.prometheus.registry
+    } else {
+      this.metricsRegistry = new client.Registry()
+      this.registerGlobals({ prometheus: { client, registry: this.metricsRegistry } })
+    }
+  }
+
+  init () {
+    return this.updateContext()
+  }
+
+  updateContext (_context) {
+    // No-op by default
+  }
+
+  start () {
+    throw new Error('BaseStackable.start must be overriden by the subclasses')
+  }
+
+  stop () {
+    throw new Error('BaseStackable.stop must be overriden by the subclasses')
+  }
+
+  build () {
+    // No-op by default
+  }
+
+  // Alias for stop
+  close () {
+    return this.stop()
+  }
+
+  inject () {
+    throw new Error('BaseStackable.inject must be overriden by the subclasses')
   }
 
   getUrl () {
     return this.url
   }
 
-  async getConfig () {
-    return this.configManager.current
+  async getConfig (includeMeta = false) {
+    if (includeMeta) {
+      return this.config
+    }
+
+    const { [kMetadata]: _, ...config } = this.config
+    return config
   }
 
   async getEnv () {
-    return this.configManager.env
+    return this.config[kMetadata].env
   }
 
   async getWatchConfig () {
-    const config = this.configManager.current
+    const config = this.config
 
     const enabled = config.watch?.enabled !== false
 
@@ -123,7 +153,7 @@ export class BaseStackable extends EventEmitter {
   }
 
   async getDispatchTarget () {
-    return this.getUrl() ?? this.getDispatchFunc()
+    return this.getUrl() ?? (await this.getDispatchFunc())
   }
 
   getMeta () {
@@ -242,7 +272,7 @@ export class BaseStackable extends EventEmitter {
   }
 
   async startWithCommand (command, loader, scripts) {
-    const config = this.configManager.current
+    const config = this.config
     const basePath = config.application?.basePath ? cleanBasePath(config.application?.basePath) : ''
 
     const context = await this.getChildManagerContext(basePath)
@@ -274,6 +304,13 @@ export class BaseStackable extends EventEmitter {
       this.basePath = path
     })
 
+    // This is not really important for the URL but sometimes it also a sign
+    // that the process has been replaced and thus we need to update the client WebSocket
+    this.childManager.on('url', (url, clientWs) => {
+      this.url = url
+      this.clientWs = clientWs
+    })
+
     try {
       await this.childManager.inject()
       this.subprocess = await this.spawn(command)
@@ -342,7 +379,7 @@ export class BaseStackable extends EventEmitter {
 
     return {
       id: this.id,
-      config: this.configManager.current,
+      config: this.config,
       serviceId: this.serviceId,
       workerId: this.workerId,
       // Always use URL to avoid serialization problem in Windows
@@ -388,46 +425,62 @@ export class BaseStackable extends EventEmitter {
     this.emit('config', config)
   }
 
+  _initializeLogger () {
+    const loggerOptions = deepmerge(this.runtimeConfig?.logger ?? {}, this.config?.logger ?? {})
+    const pinoOptions = buildPinoOptions(
+      loggerOptions,
+      this.serverConfig?.logger,
+      this.serviceId,
+      this.workerId,
+      this.context,
+      this.root
+    )
+
+    return pino(pinoOptions, this.standardStreams?.stdout)
+  }
+
   async _collectMetrics () {
     if (this.#metricsCollected) {
       return
     }
 
     this.#metricsCollected = true
+
+    if (this.context.metricsConfig === false) {
+      return
+    }
+
     await this.#collectMetrics()
     this.#setHttpCacheMetrics()
   }
 
   async #collectMetrics () {
-    let metricsConfig = this.options.context.metricsConfig
-    if (metricsConfig !== false) {
-      metricsConfig = {
-        defaultMetrics: true,
-        httpMetrics: true,
-        ...metricsConfig
-      }
-
-      if (this.childManager && this.clientWs) {
-        await this.childManager.send(this.clientWs, 'collectMetrics', {
-          serviceId: this.serviceId,
-          workerId: this.workerId,
-          metricsConfig
-        })
-        return
-      }
+    const metricsConfig = {
+      defaultMetrics: true,
+      httpMetrics: true,
+      ...this.context.metricsConfig
+    }
 
-      await collectMetrics(
-        this.serviceId,
-        this.workerId,
-        metricsConfig,
-        this.metricsRegistry
-      )
+    if (this.childManager && this.clientWs) {
+      await this.childManager.send(this.clientWs, 'collectMetrics', {
+        serviceId: this.serviceId,
+        workerId: this.workerId,
+        metricsConfig
+      })
+      return
     }
+
+    await collectMetrics(this.serviceId, this.workerId, metricsConfig, this.metricsRegistry)
   }
 
   #setHttpCacheMetrics () {
     const { client, registry } = globalThis.platformatic.prometheus
 
+    // Metrics already registered, no need to register them again
+    if (ensureMetricsGroup(registry, 'http.cache')) {
+      return
+    }
+
     const cacheHitMetric = new client.Counter({
       name: 'http_cache_hit_count',
       help: 'Number of http cache hits',

package/lib/config.js

@@ -0,0 +1,81 @@
+import {
+  listRecognizedConfigurationFiles,
+  NoConfigFileFoundError,
+  findConfigurationFile as utilsFindConfigurationFile
+} from '@platformatic/foundation'
+import jsonPatch from 'fast-json-patch'
+import { stat } from 'node:fs/promises'
+import { dirname, resolve as resolvePath } from 'node:path'
+import { workerData } from 'node:worker_threads'
+
+export async function findConfigurationFile (root, suffixes) {
+  const file = await utilsFindConfigurationFile(root, suffixes)
+
+  if (!file) {
+    const err = new NoConfigFileFoundError()
+    err.message = `No config file found in the directory ${root}. Please create one of the following files: ${listRecognizedConfigurationFiles(suffixes, ['json']).join(', ')}`
+
+    throw err
+  }
+
+  return resolvePath(root, file)
+}
+
+export async function resolve (fileOrDirectory, sourceOrConfig, suffixes) {
+  if (sourceOrConfig && typeof sourceOrConfig !== 'string') {
+    return {
+      root: fileOrDirectory,
+      source: sourceOrConfig
+    }
+  } else if (typeof fileOrDirectory === 'string' && typeof sourceOrConfig === 'string') {
+    return {
+      root: fileOrDirectory,
+      source: resolvePath(fileOrDirectory, sourceOrConfig)
+    }
+  }
+
+  try {
+    const fileInfo = await stat(fileOrDirectory)
+
+    if (fileInfo.isFile()) {
+      return {
+        root: dirname(fileOrDirectory),
+        source: fileOrDirectory
+      }
+    }
+  } catch {
+    // No-op
+  }
+
+  return {
+    root: fileOrDirectory,
+    source: await findConfigurationFile(fileOrDirectory, suffixes)
+  }
+}
+
+export async function transform (config) {
+  const patch = workerData?.serviceConfig?.configPatch
+
+  if (!config) {
+    return config
+  }
+
+  if (Array.isArray(patch)) {
+    config = jsonPatch.applyPatch(config, patch).newDocument
+  }
+
+  if (config.watch === undefined) {
+    config.watch = { enabled: workerData?.config?.watch ?? false }
+  } else if (typeof config.watch !== 'object') {
+    config.watch = { enabled: config.watch || false }
+  }
+
+  return config
+}
+
+export const validationOptions = {
+  useDefaults: true,
+  coerceTypes: true,
+  allErrors: true,
+  strict: false
+}

package/lib/creation.js

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

package/lib/modules.js

@@ -0,0 +1,101 @@
+import { detectApplicationType, findConfigurationFile } from '@platformatic/foundation'
+import { readFile } from 'node:fs/promises'
+import { createRequire } from 'node:module'
+import { relative, resolve } from 'node:path'
+import { workerData } from 'node:worker_threads'
+import pino from 'pino'
+import { packageJson } from './schema.js'
+import { importFile } from './utils.js'
+
+const importStackablePackageMarker = '__pltImportStackablePackage.js'
+
+export function isImportFailedError (error, pkg) {
+  if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND') {
+    return false
+  }
+
+  const match = error.message.match(/Cannot find package '(.+)' imported from (.+)/)
+
+  return match?.[1] === pkg || error.requireStack?.[0].endsWith(importStackablePackageMarker)
+}
+
+export async function importStackablePackage (directory, pkg) {
+  let imported
+  try {
+    try {
+      // Try regular import
+      imported = await import(pkg)
+    } catch (e) {
+      if (!isImportFailedError(e, pkg)) {
+        throw e
+      }
+
+      // Scope to the service
+      const require = createRequire(resolve(directory, importStackablePackageMarker))
+      const toImport = require.resolve(pkg)
+      imported = await importFile(toImport)
+    }
+  } catch (e) {
+    if (!isImportFailedError(e, pkg)) {
+      throw e
+    }
+
+    const serviceDirectory = 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}.`
+    )
+  }
+
+  return imported.default ?? imported
+}
+
+export async function importStackableAndConfig (root, config, context) {
+  let rootPackageJson
+  try {
+    rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
+  } catch {
+    rootPackageJson = {}
+  }
+
+  const hadConfig = !!config
+
+  if (!config) {
+    config = await findConfigurationFile(root, 'application')
+  }
+
+  const appType = await detectApplicationType(root, rootPackageJson)
+
+  if (!appType) {
+    throw new Error(`Unable to detect application type in ${root}.`)
+  }
+
+  const { label, name: moduleName } = appType
+
+  if (context) {
+    const serviceRoot = relative(process.cwd(), root)
+
+    if (!hadConfig && context.serviceId && !(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 })
+
+      logger.warn(`We have auto-detected that service "${context.serviceId}" ${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".`
+      )
+      logger.warn(`Also don't forget to add "${moduleName}" to the service dependencies.`)
+      logger.warn('You can also run "wattpm import" to do this automatically.\n')
+    }
+  }
+
+  const stackable = await importStackablePackage(root, moduleName)
+
+  return {
+    stackable,
+    config,
+    autodetectDescription:
+      moduleName === '@platformatic/node' ? 'is a generic Node.js application' : `is using ${label}`,
+    moduleName
+  }
+}

package/lib/schema.js

@@ -1,11 +1,27 @@
-import { schemaComponents as utilsSchemaComponents } from '@platformatic/utils'
+import { schemaComponents as utilsSchemaComponents } from '@platformatic/foundation'
 import { readFileSync } from 'node:fs'
 
 export const packageJson = JSON.parse(readFileSync(new URL('../package.json', import.meta.url), 'utf-8'))
+export const version = packageJson.version
 
+// This is used by applications to have common properties.
 const application = {
+  type: 'object',
+  properties: {},
+  additionalProperties: false,
+  required: [],
+  default: {}
+}
+
+/*
+  For legacy purposes, when an application is buildable (like Astro), it should use for the application properties.
+  Make sure this always extends the `application` schema above.
+*/
+
+const buildableApplication = {
   type: 'object',
   properties: {
+    ...application.properties,
     basePath: {
       type: 'string'
     },
@@ -44,7 +60,10 @@ const application = {
     }
   },
   additionalProperties: false,
-  default: {}
+  required: [...application.required],
+  default: {
+    ...application.default
+  }
 }
 
 const watch = {
@@ -59,12 +78,12 @@ const watch = {
   ]
 }
 
-export const schemaComponents = { application, watch }
+export const schemaComponents = { application, buildableApplication, watch }
 
 export const schema = {
   $id: `https://schemas.platformatic.dev/@platformatic/basic/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic Stackable',
+  title: 'Platformatic Basic Config',
   type: 'object',
   properties: {
     $schema: {

package/lib/worker/child-manager.js

@@ -1,5 +1,5 @@
+import { createDirectory, ensureLoggableError } from '@platformatic/foundation'
 import { ITC } from '@platformatic/itc'
-import { createDirectory, ensureLoggableError } from '@platformatic/utils'
 import { once } from 'node:events'
 import { rm, writeFile } from 'node:fs/promises'
 import { createServer } from 'node:http'

package/lib/worker/child-process.js

@@ -1,13 +1,12 @@
-import { ITC } from '@platformatic/itc'
-import { client, collectMetrics } from '@platformatic/metrics'
 import {
   buildPinoFormatters,
   buildPinoTimestamp,
   disablePinoDirectWrite,
-  ensureFlushedWorkerStdio,
   ensureLoggableError,
   features
-} from '@platformatic/utils'
+} from '@platformatic/foundation'
+import { ITC } from '@platformatic/itc'
+import { client, collectMetrics } from '@platformatic/metrics'
 import diagnosticChannel, { tracingChannel } from 'node:diagnostics_channel'
 import { EventEmitter, once } from 'node:events'
 import { readFile } from 'node:fs/promises'
@@ -83,7 +82,7 @@ export class ChildProcess extends ITC {
         getMetrics: (...args) => {
           return this.#getMetrics(...args)
         },
-        close: (signal) => {
+        close: signal => {
           let handled = false
 
           try {
@@ -294,7 +293,6 @@ export class ChildProcess extends ITC {
 
   #setupLogger () {
     disablePinoDirectWrite()
-    ensureFlushedWorkerStdio()
 
     // 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.

package/lib/worker/child-transport.js

@@ -1,5 +1,5 @@
+import { ensureLoggableError } from '@platformatic/foundation'
 import { generateRequest, sanitize } from '@platformatic/itc'
-import { ensureLoggableError } from '@platformatic/utils'
 import { once } from 'node:events'
 import { platform } from 'node:os'
 import { workerData } from 'node:worker_threads'

package/lib/worker/listeners.js

@@ -1,8 +1,8 @@
-import { features, withResolvers } from '@platformatic/utils'
+import { features } from '@platformatic/foundation'
 import { subscribe, tracingChannel, unsubscribe } from 'node:diagnostics_channel'
 
 export function createServerListener (overridePort = true, overrideHost) {
-  const { promise, resolve, reject } = withResolvers()
+  const { promise, resolve, reject } = Promise.withResolvers()
 
   const subscribers = {
     asyncStart ({ options }) {
@@ -48,7 +48,7 @@ export function createServerListener (overridePort = true, overrideHost) {
 }
 
 export function createChildProcessListener () {
-  const { promise, resolve } = withResolvers()
+  const { promise, resolve } = Promise.withResolvers()
 
   const handler = ({ process: child }) => {
     unsubscribe('child_process', handler)

package/package.json

@@ -1,8 +1,9 @@
 {
   "name": "@platformatic/basic",
-  "version": "2.74.3",
+  "version": "3.0.0-alpha.2",
   "description": "",
   "main": "index.js",
+  "types": "index.d.ts",
   "type": "module",
   "repository": {
     "type": "git",
@@ -18,17 +19,16 @@
     "@fastify/error": "^4.0.0",
     "execa": "^9.3.1",
     "fast-json-patch": "^3.1.1",
-    "pino": "^9.3.2",
+    "pino": "^9.9.0",
     "pino-abstract-transport": "^2.0.0",
     "semver": "^7.6.3",
     "split2": "^4.2.0",
     "undici": "^7.0.0",
     "ws": "^8.18.0",
-    "@platformatic/itc": "2.74.3",
-    "@platformatic/config": "2.74.3",
-    "@platformatic/metrics": "2.74.3",
-    "@platformatic/telemetry": "2.74.3",
-    "@platformatic/utils": "2.74.3"
+    "@platformatic/itc": "3.0.0-alpha.2",
+    "@platformatic/metrics": "3.0.0-alpha.2",
+    "@platformatic/telemetry": "3.0.0-alpha.2",
+    "@platformatic/foundation": "3.0.0-alpha.2"
   },
   "devDependencies": {
     "borp": "^0.20.0",
@@ -37,13 +37,15 @@
     "fastify": "^5.0.0",
     "get-port": "^7.1.0",
     "json-schema-to-typescript": "^15.0.0",
-    "minimatch": "^10.0.3",
     "neostandard": "^0.12.0",
     "typescript": "^5.5.4"
   },
+  "engines": {
+    "node": ">=22.18.0"
+  },
   "scripts": {
-    "test": "npm run lint && borp --concurrency=1 --no-timeout",
-    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --no-timeout",
+    "test": "npm run lint && borp --concurrency=1 --timeout 1200000",
+    "coverage": "npm run lint && borp -C -X test -X test/fixtures --concurrency=1 --timeout 1200000",
     "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",

package/schema.json

@@ -1,7 +1,7 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.74.3.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/3.0.0-alpha.2.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
-  "title": "Platformatic Stackable",
+  "title": "Platformatic Basic Config",
   "type": "object",
   "properties": {
     "$schema": {