@platformatic/basic 2.67.0 → 2.67.1

package/index.js

@@ -1,3 +1,4 @@
+import { ConfigManager } from '@platformatic/config'
 import { createRequire } from '@platformatic/utils'
 import jsonPatch from 'fast-json-patch'
 import { existsSync } from 'node:fs'
@@ -28,6 +29,10 @@ export const configCandidates = [
   'watt.tml'
 ]
 
+function hasDependency (packageJson, dependency) {
+  return packageJson.dependencies?.[dependency] || packageJson.devDependencies?.[dependency]
+}
+
 function isImportFailedError (error, pkg) {
   if (error.code !== 'ERR_MODULE_NOT_FOUND' && error.code !== 'MODULE_NOT_FOUND') {
     return false
@@ -60,15 +65,37 @@ async function importStackablePackage (directory, pkg) {
 
     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}.`
+      `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) {
-  let moduleName = '@platformatic/node'
-  let autodetectDescription = 'is using a generic Node.js application'
+export async function detectStackable (root, packageJson) {
+  let name = '@platformatic/node'
+  let label = 'Node.js'
+
+  if (hasDependency(packageJson, '@nestjs/core')) {
+    name = '@platformatic/nest'
+    label = 'NestJS'
+  } else if (hasDependency(packageJson, 'next')) {
+    name = '@platformatic/next'
+    label = 'Next.js'
+  } else if (hasDependency(packageJson, '@remix-run/dev')) {
+    name = '@platformatic/remix'
+    label = 'Remix'
+  } else if (hasDependency(packageJson, 'astro')) {
+    name = '@platformatic/astro'
+    label = 'Astro'
+    // Since Vite is often used with other frameworks, we must check for Vite last
+  } else if (hasDependency(packageJson, 'vite')) {
+    name = '@platformatic/vite'
+    label = 'Vite'
+  }
 
+  return { name, label }
+}
+
+export async function importStackableAndConfig (root, config, context) {
   let rootPackageJson
   try {
     rootPackageJson = JSON.parse(await readFile(resolve(root, 'package.json'), 'utf-8'))
@@ -76,6 +103,8 @@ export async function importStackableAndConfig (root, config) {
     rootPackageJson = {}
   }
 
+  const hadConfig = !!config
+
   if (!config) {
     for (const candidate of configCandidates) {
       const candidatePath = resolve(root, candidate)
@@ -87,53 +116,44 @@ export async function importStackableAndConfig (root, config) {
     }
   }
 
-  const { dependencies, devDependencies } = rootPackageJson
-
-  if (dependencies?.next || devDependencies?.next) {
-    autodetectDescription = 'is using Next.js'
-    moduleName = '@platformatic/next'
-  } else if (dependencies?.['@remix-run/dev'] || devDependencies?.['@remix-run/dev']) {
-    autodetectDescription = 'is using Remix'
-    moduleName = '@platformatic/remix'
-  } else if (dependencies?.astro || devDependencies?.astro) {
-    autodetectDescription = 'is using Astro'
-    moduleName = '@platformatic/astro'
-  } else if (dependencies?.vite || devDependencies?.vite) {
-    autodetectDescription = 'is using Vite'
-    moduleName = '@platformatic/vite'
+  const { label, name: moduleName } = await detectStackable(root, rootPackageJson)
+
+  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 }
+  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, autodetectDescription, moduleName } = await importStackableAndConfig(
-    opts.context.directory,
-    opts.config
-  )
+  const { stackable, config } = await importStackableAndConfig(opts.context.directory, opts.config, opts.context)
   opts.config = config
 
-  const serviceRoot = relative(process.cwd(), opts.context.directory)
-  if (
-    !hadConfig &&
-    !existsSync(resolve(serviceRoot, 'platformatic.json') || existsSync(resolve(serviceRoot, 'watt.json'))) &&
-    opts.context.worker?.count > 1
-  ) {
-    const logger = pino({
-      level: opts.context.serverConfig?.logger?.level ?? 'warn',
-      name: opts.context.serviceId
-    })
-
-    logger.warn(
-      [
-        `Platformatic has auto-detected that service "${opts.context.serviceId}" ${autodetectDescription}.\n`,
-        `We suggest you create a platformatic.json or watt.json file in the folder ${serviceRoot} with the "$schema" `,
-        `property set to "https://schemas.platformatic.dev/${moduleName}/${packageJson.version}.json".`
-      ].join('')
-    )
+  if (!hadConfig && typeof stackable.createDefaultConfig === 'function') {
+    opts.config = await stackable.createDefaultConfig?.(opts)
   }
 
   return stackable.buildStackable(opts)

package/lib/base.js

@@ -1,8 +1,8 @@
 import { client, collectMetrics } from '@platformatic/metrics'
-import { deepmerge, executeWithTimeout, buildPinoOptions } from '@platformatic/utils'
+import { buildPinoOptions, deepmerge, executeWithTimeout } from '@platformatic/utils'
 import { parseCommandString } from 'execa'
 import { spawn } from 'node:child_process'
-import { once } from 'node:events'
+import EventEmitter, { once } from 'node:events'
 import { existsSync } from 'node:fs'
 import { platform } from 'node:os'
 import { pathToFileURL } from 'node:url'
@@ -14,13 +14,17 @@ import { ChildManager } from './worker/child-manager.js'
 
 const kITC = Symbol.for('plt.runtime.itc')
 
-export class BaseStackable {
+export class BaseStackable extends EventEmitter {
   childManager
   subprocess
+  subprocessForceClose
+  subprocessTerminationSignal
   #subprocessStarted
   #metricsCollected
 
   constructor (type, version, options, root, configManager, standardStreams = {}) {
+    super()
+
     options.context.worker ??= { count: 1, index: 0 }
 
     this.type = type
@@ -48,9 +52,18 @@ export class BaseStackable {
     this.runtimeConfig = deepmerge(options.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)
+    const pinoOptions = buildPinoOptions(
+      loggerOptions,
+      this.serverConfig?.logger,
+      this.serviceId,
+      this.workerId,
+      options,
+      this.root
+    )
     this.logger = pino(pinoOptions, standardStreams?.stdout)
 
     // Setup globals
@@ -69,6 +82,7 @@ export class BaseStackable {
       prometheus: { client, registry: this.metricsRegistry },
       setCustomHealthCheck: this.setCustomHealthCheck.bind(this),
       setCustomReadinessCheck: this.setCustomReadinessCheck.bind(this),
+      notifyConfig: this.notifyConfig.bind(this),
       logger: this.logger
     })
   }
@@ -114,6 +128,22 @@ export class BaseStackable {
     return this.getUrl() ?? this.getDispatchFunc()
   }
 
+  getMeta () {
+    return {
+      composer: {
+        wantsAbsoluteUrls: false
+      }
+    }
+  }
+
+  async getMetrics ({ format } = {}) {
+    if (this.childManager && this.clientWs) {
+      return this.childManager.send(this.clientWs, 'getMetrics', { format })
+    }
+
+    return format === 'json' ? await this.metricsRegistry.getMetricsAsJSON() : await this.metricsRegistry.metrics()
+  }
+
   async getOpenapiSchema () {
     return this.openapiSchema
   }
@@ -227,6 +257,7 @@ export class BaseStackable {
 
     this.childManager.on('config', config => {
       this.subprocessConfig = config
+      this.notifyConfig(config)
     })
 
     this.childManager.on('connectionString', connectionString => {
@@ -278,13 +309,18 @@ export class BaseStackable {
     const exitPromise = once(this.subprocess, 'exit')
 
     // Attempt graceful close on the process
-    this.childManager.notify(this.clientWs, 'close')
+    const handled = await this.childManager.send(this.clientWs, 'close', this.subprocessTerminationSignal)
+
+    if (!handled && this.subprocessForceClose) {
+      this.subprocess.kill(this.subprocessTerminationSignal)
+    }
 
     // If the process hasn't exited in X seconds, kill it in the polite way
     /* c8 ignore next 10 */
     const res = await executeWithTimeout(exitPromise, exitTimeout)
+
     if (res === 'timeout') {
-      this.subprocess.kill(this.subprocessTerminationSignal ?? 'SIGINT')
+      this.subprocess.kill(this.subprocessTerminationSignal)
 
       // If the process hasn't exited in X seconds, kill it the hard way
       const res = await executeWithTimeout(exitPromise, exitTimeout)
@@ -303,6 +339,28 @@ export class BaseStackable {
     return this.childManager
   }
 
+  async getChildManagerContext (basePath) {
+    const meta = await this.getMeta()
+
+    return {
+      id: this.id,
+      config: this.configManager.current,
+      serviceId: this.serviceId,
+      workerId: this.workerId,
+      // Always use URL to avoid serialization problem in Windows
+      root: pathToFileURL(this.root).toString(),
+      basePath,
+      logLevel: this.logger.level,
+      isEntrypoint: this.isEntrypoint,
+      runtimeBasePath: this.runtimeConfig?.basePath ?? null,
+      wantsAbsoluteUrls: meta.composer?.wantsAbsoluteUrls ?? false,
+      /* c8 ignore next 2 - Else branches */
+      port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
+      host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
+      telemetryConfig: this.telemetryConfig
+    }
+  }
+
   async spawn (command) {
     const [executable, ...args] = parseCommandString(command)
     const hasChainedCommands = command.includes('&&') || command.includes('||') || command.includes(';')
@@ -328,6 +386,10 @@ export class BaseStackable {
     return subprocess
   }
 
+  notifyConfig (config) {
+    this.emit('config', config)
+  }
+
   async _collectMetrics () {
     if (this.#metricsCollected) {
       return
@@ -391,45 +453,7 @@ export class BaseStackable {
     }
   }
 
-  async getMetrics ({ format } = {}) {
-    if (this.childManager && this.clientWs) {
-      return this.childManager.send(this.clientWs, 'getMetrics', { format })
-    }
-
-    return format === 'json' ? await this.metricsRegistry.getMetricsAsJSON() : await this.metricsRegistry.metrics()
-  }
-
   async #invalidateHttpCache (opts = {}) {
     await globalThis[kITC].send('invalidateHttpCache', opts)
   }
-
-  getMeta () {
-    return {
-      composer: {
-        wantsAbsoluteUrls: false
-      }
-    }
-  }
-
-  async getChildManagerContext (basePath) {
-    const meta = await this.getMeta()
-
-    return {
-      id: this.id,
-      config: this.configManager.current,
-      serviceId: this.serviceId,
-      workerId: this.workerId,
-      // Always use URL to avoid serialization problem in Windows
-      root: pathToFileURL(this.root).toString(),
-      basePath,
-      logLevel: this.logger.level,
-      isEntrypoint: this.isEntrypoint,
-      runtimeBasePath: this.runtimeConfig?.basePath ?? null,
-      wantsAbsoluteUrls: meta.composer?.wantsAbsoluteUrls ?? false,
-      /* c8 ignore next 2 */
-      port: (this.isEntrypoint ? this.serverConfig?.port || 0 : undefined) ?? true,
-      host: (this.isEntrypoint ? this.serverConfig?.hostname : undefined) ?? true,
-      telemetryConfig: this.telemetryConfig
-    }
-  }
 }

package/lib/worker/child-process.js

@@ -1,6 +1,13 @@
 import { ITC } from '@platformatic/itc'
 import { client, collectMetrics } from '@platformatic/metrics'
-import { buildPinoFormatters, buildPinoTimestamp, disablePinoDirectWrite, ensureFlushedWorkerStdio, ensureLoggableError, features } from '@platformatic/utils'
+import {
+  buildPinoFormatters,
+  buildPinoTimestamp,
+  disablePinoDirectWrite,
+  ensureFlushedWorkerStdio,
+  ensureLoggableError,
+  features
+} from '@platformatic/utils'
 import diagnosticChannel, { tracingChannel } from 'node:diagnostics_channel'
 import { EventEmitter, once } from 'node:events'
 import { readFile } from 'node:fs/promises'
@@ -61,7 +68,6 @@ function createInterceptor () {
 export class ChildProcess extends ITC {
   #listener
   #socket
-  #child
   #logger
   #metricsRegistry
   #pendingMessages
@@ -76,6 +82,25 @@ export class ChildProcess extends ITC {
         },
         getMetrics: (...args) => {
           return this.#getMetrics(...args)
+        },
+        close: (signal) => {
+          let handled = false
+
+          try {
+            handled = globalThis.platformatic.events.emit('close', signal)
+          } catch (error) {
+            this.#logger.error({ err: ensureLoggableError(error) }, 'Error while handling close event.')
+            process.exitCode = 1
+          }
+
+          if (!handled) {
+            // No user event, just exit without errors
+            setImmediate(() => {
+              process.exit(process.exitCode ?? 0)
+            })
+          }
+
+          return handled
         }
       }
     })
@@ -92,23 +117,37 @@ export class ChildProcess extends ITC {
     this.#setupServer()
     this.#setupInterceptors()
 
-    this.on('close', () => {
-      if (!globalThis.platformatic.events.emit('close')) {
-        // No user event, just exit without errors
-        process.exit(0)
-      }
-    })
-
     this.registerGlobals({
       logger: this.#logger,
       setOpenapiSchema: this.setOpenapiSchema.bind(this),
       setGraphqlSchema: this.setGraphqlSchema.bind(this),
       setConnectionString: this.setConnectionString.bind(this),
       setBasePath: this.setBasePath.bind(this),
-      prometheus: { client, registry: this.#metricsRegistry }
+      prometheus: { client, registry: this.#metricsRegistry },
+      notifyConfig: this.#notifyConfig.bind(this)
     })
   }
 
+  registerGlobals (globals) {
+    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
+  }
+
+  setOpenapiSchema (schema) {
+    this.notify('openapiSchema', schema)
+  }
+
+  setGraphqlSchema (schema) {
+    this.notify('graphqlSchema', schema)
+  }
+
+  setConnectionString (connectionString) {
+    this.notify('connectionString', connectionString)
+  }
+
+  setBasePath (basePath) {
+    this.notify('basePath', basePath)
+  }
+
   _setupListener (listener) {
     this.#listener = listener
 
@@ -229,7 +268,7 @@ export class ChildProcess extends ITC {
   #setupServer () {
     const subscribers = {
       asyncStart ({ options }) {
-      // Unix socket, do nothing
+        // Unix socket, do nothing
         if (options.path) {
           return
         }
@@ -287,9 +326,9 @@ 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}"`
+      typeof globalThis.platformatic.workerId !== 'undefined'
+        ? `worker ${globalThis.platformatic.workerId} of the service "${globalThis.platformatic.serviceId}"`
+        : `service "${globalThis.platformatic.serviceId}"`
 
     function handleUnhandled (type, err) {
       this.#logger.error({ err: ensureLoggableError(err) }, `Child process for the ${errorLabel} threw an ${type}.`)
@@ -302,24 +341,8 @@ export class ChildProcess extends ITC {
     process.on('unhandledRejection', handleUnhandled.bind(this, 'unhandled rejection'))
   }
 
-  registerGlobals (globals) {
-    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
-  }
-
-  setOpenapiSchema (schema) {
-    this.notify('openapiSchema', schema)
-  }
-
-  setGraphqlSchema (schema) {
-    this.notify('graphqlSchema', schema)
-  }
-
-  setConnectionString (connectionString) {
-    this.notify('connectionString', connectionString)
-  }
-
-  setBasePath (basePath) {
-    this.notify('basePath', basePath)
+  #notifyConfig (config) {
+    this.notify('config', config)
   }
 }
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/basic",
-  "version": "2.67.0",
+  "version": "2.67.1",
   "description": "",
   "main": "index.js",
   "type": "module",
@@ -24,11 +24,11 @@
     "split2": "^4.2.0",
     "undici": "^7.0.0",
     "ws": "^8.18.0",
-    "@platformatic/config": "2.67.0",
-    "@platformatic/itc": "2.67.0",
-    "@platformatic/telemetry": "2.67.0",
-    "@platformatic/metrics": "2.67.0",
-    "@platformatic/utils": "2.67.0"
+    "@platformatic/itc": "2.67.1",
+    "@platformatic/config": "2.67.1",
+    "@platformatic/metrics": "2.67.1",
+    "@platformatic/telemetry": "2.67.1",
+    "@platformatic/utils": "2.67.1"
   },
   "devDependencies": {
     "borp": "^0.20.0",
@@ -37,6 +37,7 @@
     "fastify": "^5.0.0",
     "get-port": "^7.1.0",
     "json-schema-to-typescript": "^15.0.0",
+    "minimatch": "^10.0.1",
     "neostandard": "^0.12.0",
     "next": "^15.0.0",
     "react": "^18.3.1",

package/schema.json

@@ -1,5 +1,5 @@
 {
-  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.67.0.json",
+  "$id": "https://schemas.platformatic.dev/@platformatic/basic/2.67.1.json",
   "$schema": "http://json-schema.org/draft-07/schema#",
   "title": "Platformatic Stackable",
   "type": "object",