@platformatic/service 2.74.3 → 3.0.0-alpha.2

package/lib/stackable.js

@@ -1,414 +1,229 @@
-'use strict'
-
-const { hostname } = require('node:os')
-const { dirname } = require('node:path')
-const { pathToFileURL } = require('node:url')
-const { workerData } = require('node:worker_threads')
-const { printSchema } = require('graphql')
-const pino = require('pino')
-const { client, collectMetrics } = require('@platformatic/metrics')
-const { extractTypeScriptCompileOptionsFromConfig } = require('./compile')
-const { compile } = require('@platformatic/ts-compiler')
-const { deepmerge, buildPinoFormatters, buildPinoTimestamp } = require('@platformatic/utils')
-
-const kITC = Symbol.for('plt.runtime.itc')
-
-class ServiceStackable {
-  constructor (options) {
-    this.app = null
-    this._init = options.init
-    this.stackable = options.stackable
-    this.metricsRegistry = new client.Registry()
-
-    this.configManager = options.configManager
-    this.context = options.context ?? {}
-    this.context.stackable = this
-
-    this.serviceId = this.context.serviceId
-    this.context.worker ??= { count: 1, index: 0 }
-    this.workerId = this.context.worker.count > 1 ? this.context.worker.index : undefined
-
-    this.runtimeConfig = deepmerge(this.context.runtimeConfig ?? {}, workerData?.config ?? {})
-
-    this.customHealthCheck = null
-
-    this.configManager.on('error', err => {
-      /* c8 ignore next */
-      this.stackable.log({
-        message: 'error reloading the configuration' + err,
-        level: 'error'
-      })
-    })
-
-    this.#updateConfig()
-
-    // Setup globals
-    this.registerGlobals({
-      serviceId: this.serviceId,
-      workerId: this.workerId,
-      // Always use URL to avoid serialization problem in Windows
-      root: this.context.directory ? pathToFileURL(this.context.directory).toString() : undefined,
-      setOpenapiSchema: this.setOpenapiSchema.bind(this),
-      setGraphqlSchema: this.setGraphqlSchema.bind(this),
-      setConnectionString: this.setConnectionString.bind(this),
-      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)
-    })
+import { BaseStackable, cleanBasePath, ensureTrailingSlash, getServerUrl } from '@platformatic/basic'
+import { buildPinoFormatters, buildPinoTimestamp, deepmerge, features, isKeyEnabled } from '@platformatic/foundation'
+import { telemetry } from '@platformatic/telemetry'
+import fastify from 'fastify'
+import { printSchema } from 'graphql'
+import { randomUUID } from 'node:crypto'
+import { hostname } from 'node:os'
+import pino from 'pino'
+import { platformaticService } from './application.js'
+import { setupRoot } from './plugins/root.js'
+import { version } from './schema.js'
+import { sanitizeHTTPSArgument } from './utils.js'
+
+export class ServiceStackable extends BaseStackable {
+  #app
+  #basePath
+
+  constructor (root, config, context) {
+    super('service', version, root, config, context)
+    this.applicationFactory = this.context.applicationFactory ?? platformaticService
   }
 
   async init () {
-    this.#initLogger()
-
-    if (this.app === null) {
-      this.app = await this._init()
-      await this.#collectMetrics()
-    }
-    return this.app
-  }
-
-  async start (options = {}) {
-    await this.init()
+    await super.init()
 
-    if (options.listen === false) {
-      await this.app.ready()
+    if (this.#app) {
       return
     }
-    await this.app.start()
-  }
 
-  async stop () {
-    if (this.app === null) return
-    await this.app.close()
-  }
+    const config = this.config
+    this.#basePath = ensureTrailingSlash(cleanBasePath(config.basePath ?? this.serviceId))
 
-  async build () {
-    this.#initLogger()
-    const typeScriptCompileOptions = extractTypeScriptCompileOptionsFromConfig(this.configManager.current)
-    const cwd = dirname(this.configManager.fullPath)
-    const compileOptions = {
-      ...typeScriptCompileOptions,
-      cwd,
-      logger: this.logger
+    // Create the application
+    this.#app = fastify({
+      ...this.serverConfig,
+      ...this.fastifyOptions,
+      genReqId () {
+        return randomUUID()
+      }
+    })
+
+    // This must be done before loading the plugins, so they can inspect if the
+    // openTelemetry decorator exists and then configure accordingly.
+    if (isKeyEnabled('telemetry', config)) {
+      await this.#app.register(telemetry, config.telemetry)
     }
 
-    await compile(compileOptions)
-  }
+    this.#app.decorate('platformatic', { config: this.config })
 
-  getUrl () {
-    return this.app !== null ? this.app.url : null
-  }
+    await this.#app.register(this.applicationFactory, this)
 
-  async getInfo () {
-    const type = this.stackable.configType
-    const version = this.stackable.configManagerConfig.version ?? null
-    return { type, version }
-  }
+    if (Array.isArray(this.context.fastifyPlugins)) {
+      for (const plugin of this.context.fastifyPlugins) {
+        await this.#app.register(plugin)
+      }
+    }
 
-  async getConfig () {
-    const config = Object.assign({}, this.configManager.current)
-    config.server = Object.assign({}, config.server)
+    if (!this.#app.hasRoute({ url: '/', method: 'GET' }) && !this.#app.hasRoute({ url: '/*', method: 'GET' })) {
+      await this.#app.register(setupRoot)
+    }
+  }
 
-    const logger = config.server.loggerInstance
+  async start (startOptions) {
+    // Compatibility with v2 service
+    const { listen } = startOptions ?? { listen: true }
 
-    if (logger) {
-      config.server.logger = {}
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
 
-      if (logger.level) {
-        config.server.logger.level = logger.level
-      }
+    // Create the application if needed
+    if (!this.#app) {
+      await this.init()
+      await this.#app.ready()
     }
 
-    delete config.server.loggerInstance
+    if (listen) {
+      await this._listen()
+    }
 
-    return config
+    await this._collectMetrics()
+    return this.url
   }
 
-  async getEnv () {
-    return this.configManager.env
+  async stop () {
+    return this.#app?.close()
   }
 
-  getMeta () {
-    const config = this.configManager.current
+  async inject (injectParams, onInject) {
+    const response = await this.#app.inject(injectParams, onInject)
 
-    return {
-      composer: {
-        prefix: config.basePath ?? this.basePath ?? this.context?.serviceId,
-        wantsAbsoluteUrls: false,
-        needsRootTrailingSlash: false,
-        tcp: !!this.app?.url,
-        url: this.app?.url
-      },
-      connectionStrings: [this.connectionString]
+    if (onInject) {
+      return
     }
-  }
-
-  async getWatchConfig () {
-    const config = this.configManager.current
 
-    const enabled = config.watch?.enabled !== false && config.plugins !== undefined
+    const { statusCode, statusMessage, headers, body } = response
+    return { statusCode, statusMessage, headers, body }
+  }
 
-    return {
-      enabled,
-      path: this.configManager.dirname ?? dirname(this.configManager.fullPath),
-      allow: config.watch?.allow,
-      ignore: config.watch?.ignore
-    }
+  getApplication () {
+    return this.#app
   }
 
   async getDispatchFunc () {
     await this.init()
-    return this.app
+    return this.#app
   }
 
-  async getDispatchTarget () {
-    return this.getUrl() ?? (await this.getDispatchFunc())
-  }
+  async getConfig (includeMeta = false) {
+    let config = await super.getConfig(includeMeta)
+    const loggerInstance = this.serverConfig?.loggerInstance
 
-  async getOpenapiSchema () {
-    await this.init()
-    await this.app.ready()
-    return this.app.swagger ? this.app.swagger() : null
-  }
-
-  async getGraphqlSchema () {
-    await this.init()
-    await this.app.ready()
-    return this.app.graphql ? printSchema(this.app.graphql.schema) : null
-  }
+    if (loggerInstance) {
+      config = Object.assign({}, config)
+      const { loggerInstance: _, ...serverConfig } = this.serverConfig
+      config.server = { ...serverConfig, logger: { level: loggerInstance.level } }
+    }
 
-  setCustomHealthCheck (fn) {
-    this.customHealthCheck = fn
+    return config
   }
 
-  async getCustomHealthCheck () {
-    if (!this.customHealthCheck) {
-      return true
-    }
-    return await this.customHealthCheck()
-  }
+  async getWatchConfig () {
+    const config = this.config
 
-  setCustomReadinessCheck (fn) {
-    this.customReadinessCheck = fn
-  }
+    const enabled = config.watch?.enabled !== false && config.plugins !== undefined
 
-  async getCustomReadinessCheck () {
-    if (!this.customReadinessCheck) {
-      return true
+    if (!enabled) {
+      return { enabled, path: this.root }
     }
-    return await this.customReadinessCheck()
-  }
 
-  // This method is not a part of Stackable interface because we need to register
-  // fastify metrics before the server is started.
-  async #collectMetrics () {
-    const metricsConfig = this.context.metricsConfig
-
-    if (metricsConfig !== false) {
-      await collectMetrics(
-        this.serviceId,
-        this.workerId,
-        {
-          defaultMetrics: true,
-          httpMetrics: true,
-          ...metricsConfig
-        },
-        this.metricsRegistry
-      )
-
-      this.#setHttpCacheMetrics()
+    return {
+      enabled,
+      path: this.root,
+      allow: config.watch?.allow,
+      ignore: config.watch?.ignore
     }
   }
 
-  async getMetrics (opts) {
-    const format = opts?.format
-    return format === 'json' ? await this.metricsRegistry.getMetricsAsJSON() : await this.metricsRegistry.metrics()
+  getMeta () {
+    return {
+      composer: {
+        tcp: typeof this.url !== 'undefined',
+        url: this.url,
+        prefix: this.basePath ?? this.#basePath,
+        wantsAbsoluteUrls: false,
+        needsRootTrailingSlash: false
+      },
+      connectionStrings: [this.connectionString]
+    }
   }
 
-  async inject (injectParams) {
+  async getOpenapiSchema () {
     await this.init()
-
-    const { statusCode, statusMessage, headers, body } = await this.app.inject(injectParams)
-    return { statusCode, statusMessage, headers, body }
+    await this.#app.ready()
+    return this.#app.swagger ? this.#app.swagger() : null
   }
 
-  async log (options = {}) {
+  async getGraphqlSchema () {
     await this.init()
-
-    const logLevel = options.level ?? 'info'
-
-    const message = options.message
-    if (!message) return
-
-    this.app.log[logLevel](message)
+    await this.#app.ready()
+    return this.#app.graphql ? printSchema(this.#app.graphql.schema) : null
   }
 
   async updateContext (context) {
-    this.context = { ...this.context, ...context }
-    this.#updateConfig()
-  }
-
-  setOpenapiSchema (schema) {
-    this.openapiSchema = schema
-  }
-
-  setGraphqlSchema (schema) {
-    this.graphqlSchema = schema
-  }
-
-  setConnectionString (connectionString) {
-    this.connectionString = connectionString
-  }
-
-  setBasePath (basePath) {
-    this.basePath = basePath
-  }
-
-  registerGlobals (globals) {
-    globalThis.platformatic = Object.assign(globalThis.platformatic ?? {}, globals)
-  }
-
-  async #invalidateHttpCache (opts = {}) {
-    await globalThis[kITC].send('invalidateHttpCache', opts)
-  }
-
-  #setHttpCacheMetrics () {
-    const { client, registry } = globalThis.platformatic.prometheus
-
-    const cacheHitMetric = new client.Counter({
-      name: 'http_cache_hit_count',
-      help: 'Number of http cache hits',
-      registers: [registry]
-    })
-
-    const cacheMissMetric = new client.Counter({
-      name: 'http_cache_miss_count',
-      help: 'Number of http cache misses',
-      registers: [registry]
-    })
-
-    globalThis.platformatic.onHttpCacheHit = () => {
-      cacheHitMetric.inc()
-    }
-    globalThis.platformatic.onHttpCacheMiss = () => {
-      cacheMissMetric.inc()
-    }
-
-    const httpStatsFreeMetric = new client.Gauge({
-      name: 'http_client_stats_free',
-      help: 'Number of free (idle) http clients (sockets)',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsFree = (url, val) => {
-      httpStatsFreeMetric.set({ dispatcher_stats_url: url }, val)
-    }
-
-    const httpStatsConnectedMetric = new client.Gauge({
-      name: 'http_client_stats_connected',
-      help: 'Number of open socket connections',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsConnected = (url, val) => {
-      httpStatsConnectedMetric.set({ dispatcher_stats_url: url }, val)
-    }
-
-    const httpStatsPendingMetric = new client.Gauge({
-      name: 'http_client_stats_pending',
-      help: 'Number of pending requests across all clients',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsPending = (url, val) => {
-      httpStatsPendingMetric.set({ dispatcher_stats_url: url }, val)
-    }
+    super.updateContext(context)
 
-    const httpStatsQueuedMetric = new client.Gauge({
-      name: 'http_client_stats_queued',
-      help: 'Number of queued requests across all clients',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsQueued = (url, val) => {
-      httpStatsQueuedMetric.set({ dispatcher_stats_url: url }, val)
-    }
-
-    const httpStatsRunningMetric = new client.Gauge({
-      name: 'http_client_stats_running',
-      help: 'Number of currently active requests across all clients',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsRunning = (url, val) => {
-      httpStatsRunningMetric.set({ dispatcher_stats_url: url }, val)
-    }
+    this.context = { ...this.context, ...context }
 
-    const httpStatsSizeMetric = new client.Gauge({
-      name: 'http_client_stats_size',
-      help: 'Number of active, pending, or queued requests across all clients',
-      labelNames: ['dispatcher_stats_url'],
-      registers: [registry]
-    })
-    globalThis.platformatic.onHttpStatsSize = (url, val) => {
-      httpStatsSizeMetric.set({ dispatcher_stats_url: url }, val)
+    if (!this.context) {
+      return
     }
-  }
 
-  #updateConfig () {
-    if (!this.context) return
+    const { telemetryConfig, serverConfig, isEntrypoint, isProduction, logger } = this.context
 
-    const { serviceId, telemetryConfig, metricsConfig, serverConfig, hasManagementApi, isEntrypoint, isProduction } =
-      this.context
-
-    const config = this.configManager.current
+    const config = { ...this.config }
 
     if (telemetryConfig) {
       config.telemetry = telemetryConfig
     }
-    if (metricsConfig) {
-      config.metrics = metricsConfig
-    }
+
+    const loggerInstance = logger ?? serverConfig?.loggerInstance ?? this.serverConfig?.loggerInstance
+
     if (serverConfig) {
-      config.server = deepmerge(config.server ?? {}, serverConfig ?? {})
+      config.server = deepmerge(this.serverConfig, serverConfig ?? {})
     }
 
-    if ((hasManagementApi && config.metrics === undefined) || config.metrics) {
-      const labels = config.metrics?.labels || {}
-      config.metrics = {
-        server: 'hide',
-        defaultMetrics: { enabled: isEntrypoint },
-        ...config.metrics,
-        labels: { serviceId, ...labels }
+    config.server ??= {}
+
+    if (isProduction) {
+      if (config.plugins) {
+        config.plugins.typescript = false
       }
+      config.watch = { enabled: false }
     }
 
+    // Adjust server options
     if (!isEntrypoint) {
-      config.server = config.server ?? {}
       config.server.trustProxy = true
     }
 
-    if (isProduction) {
-      if (config.plugins) {
-        config.plugins.typescript = false
-      }
-      config.watch = { enabled: false }
+    if (config.server.https) {
+      config.server.https.key = await sanitizeHTTPSArgument(config.server.https.key)
+      config.server.https.cert = await sanitizeHTTPSArgument(config.server.https.cert)
     }
 
-    this.configManager.update(config)
+    // Assign the logger instance if it exists
+    if (loggerInstance) {
+      config.server = { ...config.server }
+      config.server.loggerInstance = loggerInstance
+      delete config.server.logger
+    }
+
+    this.serverConfig = config.server
+    this.config = config
   }
 
-  #initLogger () {
-    if (this.configManager.current.server?.loggerInstance) {
-      this.logger = this.configManager.current.server?.loggerInstance
-      return
+  _initializeLogger () {
+    if (this.context?.logger) {
+      return this.context.logger
+    } else if (this.config.server?.loggerInstance) {
+      return this.config.server?.loggerInstance
     }
 
-    this.configManager.current.server ??= {}
-    this.loggerConfig = deepmerge(this.context.loggerConfig ?? {}, this.configManager.current.server?.logger ?? {})
+    this.serverConfig ??= {}
+    this.loggerConfig = deepmerge(this.context.loggerConfig ?? {}, this.serverConfig?.logger ?? {})
 
     const pinoOptions = {
       ...(this.loggerConfig ?? {}),
@@ -436,12 +251,30 @@ class ServiceStackable {
       pinoOptions.timestamp = buildPinoTimestamp(this.loggerConfig?.timestamp)
     }
 
-    this.logger = pino(pinoOptions)
+    const logger = pino(pinoOptions)
 
     // Only one of logger and loggerInstance should be set
-    delete this.configManager.current.server.logger
-    this.configManager.current.server.loggerInstance = this.logger
+    this.serverConfig.loggerInstance = logger
+    delete this.serverConfig.logger
+
+    return logger
   }
-}
 
-module.exports = { ServiceStackable }
+  async _listen () {
+    const serverOptions = this.serverConfig
+    const listenOptions = { host: serverOptions?.hostname || '127.0.0.1', port: serverOptions?.port || 0 }
+
+    if (this.isProduction && features.node.reusePort) {
+      listenOptions.reusePort = true
+    }
+
+    await this.#app.listen(listenOptions)
+    this.url = getServerUrl(this.#app.server)
+
+    if (this.serverConfig.http2 || this.serverConfig.https?.key) {
+      this.url = this.url.replace('http://', 'https://')
+    }
+
+    return this.url
+  }
+}

package/lib/upgrade.js

@@ -1,15 +1,13 @@
-'use strict'
-
-const { join } = require('path')
-
-module.exports = async function upgrade (config, version) {
-  const { semgrator } = await import('semgrator')
+import { abstractLogger } from '@platformatic/foundation'
+import { resolve } from 'node:path'
+import { semgrator } from 'semgrator'
 
+export async function upgrade (logger, config, version) {
   const iterator = semgrator({
     version,
-    path: join(__dirname, 'versions'),
+    path: resolve(import.meta.dirname, 'versions'),
     input: config,
-    logger: this.logger.child({ name: '@platformatic/service' }),
+    logger: logger?.child({ name: '@platformatic/service' }) ?? abstractLogger
   })
 
   let result