@platformatic/basic 3.4.1 → 3.5.0

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?.applicationConfig?.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 { importCapabilityAndConfig } from './modules.js'
+
+export async function create (fileOrDirectory, sourceOrConfig, context) {
+  const { root, source } = await resolve(fileOrDirectory, sourceOrConfig)
+  const { capability } = await importCapabilityAndConfig(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

@@ -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 importCapabilityPackageMarker = '__pltImportCapabilityPackage.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(importCapabilityPackageMarker)
+}
+
+export async function importCapabilityPackage (directory, pkg) {
+  let imported
+  try {
+    try {
+      // Try regular import
+      imported = await import(pkg)
+    } catch (e) {
+      if (!isImportFailedError(e, pkg)) {
+        throw e
+      }
+
+      // Scope to the application
+      const require = createRequire(resolve(directory, importCapabilityPackageMarker))
+      const toImport = require.resolve(pkg)
+      imported = await importFile(toImport)
+    }
+  } catch (e) {
+    if (!isImportFailedError(e, pkg)) {
+      throw e
+    }
+
+    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 ${applicationDirectory}.`
+    )
+  }
+
+  return imported.default ?? imported
+}
+
+export async function importCapabilityAndConfig (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 applicationRoot = relative(process.cwd(), root)
+
+    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.applicationId })
+
+      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 ${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 application dependencies.`)
+      logger.warn('You can also run "wattpm import" to do this automatically.\n')
+    }
+  }
+
+  const capability = await importCapabilityPackage(root, moduleName)
+
+  return {
+    capability,
+    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'
     },
@@ -28,7 +44,7 @@ const application = {
           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'
         },
@@ -44,7 +60,10 @@ const application = {
     }
   },
   additionalProperties: false,
-  default: {}
+  required: [...application.required],
+  default: {
+    ...application.default
+  }
 }
 
 const watch = {
@@ -59,17 +78,18 @@ 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: {
       type: 'string'
-    }
+    },
+    runtime: utilsSchemaComponents.wrappedRuntime
   },
   additionalProperties: true
 }

package/lib/utils.js

@@ -62,8 +62,10 @@ export function importFile (path) {
 /* c8 ignore next 6 */
 export function resolvePackage (root, pkg) {
   const require = createRequire(root)
-
-  return require.resolve(pkg, { paths: [root, ...require.main.paths] })
+  // We need to add the main module paths to the require.resolve call
+  // Note that `require.main` is not defined in `next` if we set sthe instrumentation hook reequired for ESM applications.
+  // see: https://github.com/open-telemetry/opentelemetry-js/blob/main/doc/esm-support.md#instrumentation-hook-required-for-esm
+  return require.resolve(pkg, { paths: [root, ...(require.main?.paths || [])] })
 }
 
 export function cleanBasePath (basePath) {

package/lib/worker/child-manager.js

@@ -1,16 +1,17 @@
-import { ITC, generateNotification } from '@platformatic/itc'
-import { createDirectory, ensureLoggableError } from '@platformatic/utils'
+import { createDirectory, ensureLoggableError } from '@platformatic/foundation'
+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'
-import { register } from 'node:module'
+import { createRequire, register } from 'node:module'
 import { platform, tmpdir } from 'node:os'
-import { dirname, resolve } from 'node:path'
-import { workerData } from 'node:worker_threads'
+import { dirname, join, resolve } from 'node:path'
+import { pathToFileURL } from 'node:url'
 import { request } from 'undici'
 import { WebSocketServer } from 'ws'
 import { exitCodes } from '../errors.js'
 import { ensureFileUrl } from '../utils.js'
+
 export const isWindows = platform() === 'win32'
 
 // In theory we could use the context.id to namespace even more, but due to
@@ -41,9 +42,11 @@ export class ChildManager extends ITC {
   #scripts
   #logger
   #server
+  #websocketServer
   #socketPath
   #clients
   #requests
+  #currentSender
   #currentClient
   #listener
   #originalNodeOptions
@@ -56,19 +59,8 @@ export class ChildManager extends ITC {
     scripts ??= []
 
     super({
-      name: 'child-manager',
       ...itcOpts,
-      handlers: {
-        log: message => {
-          /* c8 ignore next */
-          const logs = Array.isArray(message.logs) ? message.logs : [message.logs]
-          this._forwardLogs(logs)
-        },
-        fetch: request => {
-          return this.#fetch(request)
-        },
-        ...itcOpts.handlers
-      }
+      name: 'child-manager'
     })
 
     this.#id = generateChildrenId(context)
@@ -77,7 +69,7 @@ export class ChildManager extends ITC {
     this.#scripts = scripts
     this.#originalNodeOptions = process.env.NODE_OPTIONS
     this.#logger = globalThis.platformatic.logger
-    this.#server = createServer()
+    this.#server = createServer(this.#childProcessFetchHandler.bind(this))
     this.#socketPath ??= getSocketPath(this.#id)
     this.#clients = new Set()
     this.#requests = new Map()
@@ -90,18 +82,21 @@ export class ChildManager extends ITC {
       await createDirectory(dirname(this.#socketPath))
     }
 
-    const wssServer = new WebSocketServer({ server: this.#server })
+    this.#websocketServer = new WebSocketServer({ server: this.#server })
 
-    wssServer.on('connection', ws => {
+    this.#websocketServer.on('connection', ws => {
       this.#clients.add(ws)
 
       ws.on('message', raw => {
         try {
+          this.#currentSender = ws
           const message = JSON.parse(raw)
           this.#requests.set(message.reqId, ws)
           this.#listener(message)
         } catch (error) {
           this.#handleUnexpectedError(error, 'Handling a message failed.', exitCodes.MANAGER_MESSAGE_HANDLING_FAILED)
+        } finally {
+          this.#currentSender = null
         }
       })
 
@@ -124,24 +119,25 @@ export class ChildManager extends ITC {
     })
   }
 
-  async close (signal) {
+  async close () {
     if (this.#dataPath) {
       await rm(this.#dataPath, { force: true })
     }
 
     for (const client of this.#clients) {
-      this.#currentClient = client
-      this._send(generateNotification('close', signal))
+      client.close()
+      await once(client, 'close')
     }
 
-    this.#server?.close()
-    super.close()
+    await this.#closeServer(this.#websocketServer)
+    await this.#closeServer(this.#server)
+    await super.close()
   }
 
   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))
 
@@ -161,8 +157,19 @@ export class ChildManager extends ITC {
     )
 
     process.env.PLT_MANAGER_ID = this.#id
-    process.env.NODE_OPTIONS =
-      `--import="${new URL('./child-process.js', import.meta.url)}" ${process.env.NODE_OPTIONS ?? ''}`.trim()
+
+    const nodeOptions = process.env.NODE_OPTIONS ?? ''
+    const childProcessInclude = `--import="${new URL('./child-process.js', import.meta.url)}"`
+
+    let telemetryInclude = ''
+    if (this.#context.telemetryConfig && this.#context.telemetryConfig.enabled !== false) {
+      const require = createRequire(import.meta.url)
+      const telemetryPath = require.resolve('@platformatic/telemetry')
+      const openTelemetrySetupPath = join(telemetryPath, '..', 'lib', 'node-telemetry.js')
+      telemetryInclude = `--import="${pathToFileURL(openTelemetrySetupPath)}"`
+    }
+
+    process.env.NODE_OPTIONS = `${telemetryInclude} ${childProcessInclude} ${nodeOptions}`.trim()
   }
 
   async eject () {
@@ -179,14 +186,24 @@ export class ChildManager extends ITC {
   }
 
   register () {
+    Object.assign(globalThis.platformatic, this.#context)
     register(this.#loader, { data: this.#context })
   }
 
+  emit (...args) {
+    super.emit(...args, this.#currentSender)
+  }
+
   send (client, name, message) {
     this.#currentClient = client
     return super.send(name, message)
   }
 
+  notify (client, name, message) {
+    this.#currentClient = client
+    return super.notify(name, message)
+  }
+
   _send (message, stringify = true) {
     if (!this.#currentClient) {
       this.#currentClient = this.#requests.get(message.reqId)
@@ -213,22 +230,50 @@ export class ChildManager extends ITC {
     this.#server.close()
   }
 
-  /* c8 ignore next 3 */
-  _forwardLogs (logs) {
-    workerData.loggingPort.postMessage({ logs: logs.map(m => JSON.stringify(m)) })
-  }
+  async #childProcessFetchHandler (req, res) {
+    const { url, headers } = req
 
-  async #fetch (opts) {
-    const { statusCode, headers, body } = await request(opts)
+    const requestOptions = { method: req.method, headers }
 
-    const rawPayload = Buffer.from(await body.arrayBuffer())
-    const payload = rawPayload.toString()
+    if (req.method !== 'GET' && req.method !== 'HEAD') {
+      requestOptions.body = req
+    }
 
-    return { statusCode, headers, body: payload, payload, rawPayload }
+    try {
+      const {
+        statusCode,
+        headers: responseHeaders,
+        body
+      } = await request(`http://${headers.host}${url ?? '/'}`, requestOptions)
+
+      res.writeHead(statusCode, responseHeaders)
+      body.pipe(res)
+    } catch (error) {
+      res.writeHead(502, { 'content-type': 'application/json' })
+      res.end(JSON.stringify(ensureLoggableError(error)))
+    }
   }
 
   #handleUnexpectedError (error, message, exitCode) {
     this.#logger.error({ err: ensureLoggableError(error) }, message)
     process.exit(exitCode)
   }
+
+  #closeServer (server) {
+    return new Promise((resolve, reject) => {
+      if (!server || server.listening === false) {
+        resolve()
+        return
+      }
+
+      server.close(err => {
+        if (err) {
+          reject(err)
+          return
+        }
+
+        resolve()
+      })
+    })
+  }
 }