@platformatic/service 3.4.1 → 3.5.0

package/index.d.ts

@@ -1,66 +1,73 @@
-/// <reference types="mercurius" />
-/// <reference types="@fastify/swagger" />
-import { FastifyInstance, FastifyBaseLogger } from 'fastify'
-import ConfigManager from '@platformatic/config'
-import type { ConfigManagerConfig } from '@platformatic/config'
-import type { Stackable as _Stackable, StackableInterface } from '@platformatic/config'
+import { BaseCapability, BaseContext, BaseOptions } from '@platformatic/basic'
+import { Configuration, ConfigurationOptions } from '@platformatic/foundation'
 import { BaseGenerator } from '@platformatic/generators'
-import { PlatformaticService } from './config'
-import type { JSONSchemaType } from 'ajv'
-import { ServiceGenerator } from './lib/generator/service-generator'
+import { JSONSchemaType } from 'ajv'
+import { FastifyInstance } from 'fastify'
+import type { PlatformaticServiceConfig } from './config.d.ts'
 
-export import Generator = ServiceGenerator.ServiceGenerator
+export type { PlatformaticServiceConfig } from './config.d.ts'
 
-export interface PlatformaticApp<T> {
-  configManager: ConfigManager<T>
-  config: T
+export interface ServiceContext extends BaseContext {
+  applicationFactory?: typeof platformaticService
+  fastifyPlugins?: Function[]
 }
 
-export type PlatformaticServiceConfig = PlatformaticService
-
-export function buildServer (opts: object, app?: object, ConfigManagerConstructor?: object): Promise<FastifyInstance>
-export function start<ConfigType> (app: Stackable<ConfigType>, args: string[]): Promise<void>
+export interface PlatformaticApplication<Config> {
+  config: Configuration<Config>
+}
 
-declare module 'fastify' {
-  interface FastifyInstance {
-    restart: () => Promise<void>
-  }
+export type ServerInstance<Configuration = PlatformaticServiceConfig> = FastifyInstance & {
+  platformatic: PlatformaticApplication<Configuration>
 }
 
-type DefaultGenerator = new () => BaseGenerator.BaseGenerator
+export type ServiceConfiguration<T = {}> = Configuration<PlatformaticServiceConfig & T>
 
-export interface Stackable<ConfigType, Generator = DefaultGenerator> extends _Stackable<ConfigType> {
-  app: (app: FastifyInstance, opts: object) => Promise<void>
-  Generator?: Generator
-  version?: string
-  upgrade?: (config: any, version: string) => Promise<any>
-  transformConfig?: (config: any) => Promise<any>
-  buildStackable: (opts: { config: string }, app?: object) => Promise<StackableInterface>
-}
+export declare function transform (config: ServiceConfiguration): Promise<ServiceConfiguration>
 
-interface TSCompilerOptions {
-  clean: boolean
-}
-interface TSCompiler {
-  compile: (cwd: string, config: object, originalLogger: FastifyBaseLogger, options: TSCompilerOptions) => Promise<boolean>
-}
+export declare function loadConfiguration (
+  root: string | PlatformaticServiceConfig,
+  source?: string | PlatformaticServiceConfig,
+  context?: ConfigurationOptions
+): Promise<Configuration<PlatformaticServiceConfig>>
+
+export declare function create (
+  root: string | PlatformaticServiceConfig,
+  source?: string | PlatformaticServiceConfig,
+  context?: ConfigurationOptions
+): Promise<ServiceCapability>
 
-export const schema: JSONSchemaType<PlatformaticServiceConfig>
-export const configManagerConfig: ConfigManagerConfig<PlatformaticServiceConfig>
+export declare const skipTelemetryHooks: boolean
 
-export declare const platformaticService: Stackable<PlatformaticServiceConfig>
+export declare function platformaticService (app: FastifyInstance, capability: ServiceCapability): Promise<void>
 
-export declare const app: (app: FastifyInstance, opts: object) => Promise<void>
+export declare class Generator extends BaseGenerator {}
+export declare function applyTestHelperCustomizations (
+  helper: string,
+  mod: string,
+  customizations: Record<string, string>
+): string
 
-export const tsCompiler: TSCompiler
+export declare const packageJson: Record<string, unknown>
 
-type defaultExport = Stackable<PlatformaticServiceConfig> & {
-  buildServer: (opts: object, app?: object, ConfigManagerConstructor?: object) => Promise<FastifyInstance>,
-  start: <ConfigType>(app: Stackable<ConfigType>, args: string[]) => Promise<void>,
-  tsCompiler: TSCompiler,
-  schema: JSONSchemaType<PlatformaticServiceConfig>,
+export declare const schema: JSONSchemaType<PlatformaticServiceConfig>
+
+export declare const schemaComponents: {
+  $defs: JSONSchemaType<object>
+  plugins: JSONSchemaType<object>
+  openApiBase: JSONSchemaType<object>
+  openapi: JSONSchemaType<object>
+  proxy: JSONSchemaType<object>
+  graphqlBase: JSONSchemaType<object>
+  graphql: JSONSchemaType<object>
+  application: JSONSchemaType<object>
 }
 
-export function buildStackable (opts: { config: string }, app?: object): Promise<StackableInterface>
+export declare const version: string
 
-export default defaultExport
+export declare class ServiceCapability<Config = PlatformaticServiceConfig> extends BaseCapability<
+  Config,
+  BaseOptions<ServiceContext>
+> {
+  constructor (root: string, config: Config, context?: object)
+  getApplication (): FastifyInstance
+}

package/index.js

@@ -1,198 +1,63 @@
-'use strict'
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/foundation'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { ServiceCapability } from './lib/capability.js'
+import { schema } from './lib/schema.js'
+import { upgrade } from './lib/upgrade.js'
+import { isDocker } from './lib/utils.js'
 
-const { isKeyEnabled } = require('@platformatic/utils')
-const { loadConfig, ConfigManager } = require('@platformatic/config')
-const { readFile } = require('fs/promises')
-const { join } = require('path')
+export async function transform (config, schema, options) {
+  config = await basicTransform(config, schema, options)
 
-const setupCors = require('./lib/plugins/cors')
-const setupOpenAPI = require('./lib/plugins/openapi.js')
-const setupGraphQL = require('./lib/plugins/graphql.js')
-const setupClients = require('./lib/plugins/clients')
-const setupMetrics = require('./lib/plugins/metrics')
-const setupTsCompiler = require('./lib/plugins/typescript')
-const setupHealthCheck = require('./lib/plugins/health-check')
-const loadPlugins = require('./lib/plugins/plugins')
-const upgrade = require('./lib/upgrade')
-const { telemetry } = require('@platformatic/telemetry')
-
-const { buildCompileCmd, extractTypeScriptCompileOptionsFromConfig } = require('./lib/compile')
-const { schema } = require('./lib/schema')
-const { addLoggerToTheConfig } = require('./lib/utils')
-const { start, buildServer } = require('./lib/start')
-const ServiceGenerator = require('./lib/generator/service-generator.js')
-const { ServiceStackable } = require('./lib/stackable')
-
-const { version } = require('./package.json')
-
-// TODO(mcollina): arugments[2] is deprecated, remove it in the next major version.
-async function platformaticService (app, opts) {
-  const configManager = app.platformatic.configManager
-  const config = configManager.current
-  const beforePlugins = opts.beforePlugins || arguments[2] || []
-
-  if (isKeyEnabled('metrics', config)) {
-    if (config.metrics.server === 'own' && parseInt(config.server.port) === parseInt(config.metrics.port)) {
-      app.log.warn('In order to serve metrics on the same port as the core applicaton, set metrics.server to "parent".')
-      config.metrics.server = 'parent'
-    }
-
-    app.register(setupMetrics, config.metrics)
-  }
-
-  // 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 app.register(telemetry, config.telemetry)
-  }
-
-  // This must be done before loading the plugins, so they can be
-  // configured accordingly
-  if (isKeyEnabled('clients', config)) {
-    app.register(setupClients, config.clients)
+  if (config.server && (await isDocker())) {
+    config.server.hostname = '0.0.0.0'
   }
 
-  if (Array.isArray(beforePlugins)) {
-    for (const plugin of beforePlugins) {
-      app.register(plugin)
-    }
-  }
+  const typescript = config.plugins?.typescript
 
-  const serviceConfig = config.service || {}
-
-  if (isKeyEnabled('openapi', serviceConfig)) {
-    const openapi = serviceConfig.openapi
-    app.register(setupOpenAPI, { openapi })
-  }
+  if (typescript) {
+    let { outDir, tsConfigFile } = typescript
+    tsConfigFile ??= 'tsconfig.json'
 
-  if (isKeyEnabled('graphql', serviceConfig)) {
-    app.register(setupGraphQL, serviceConfig.graphql)
-  }
-
-  if (config.plugins) {
-    let registerTsCompiler = false
-    const typescript = config.plugins.paths && config.plugins.typescript
-    /* c8 ignore next 6 */
-    if (typescript === true) {
-      registerTsCompiler = true
-    } else if (typeof typescript === 'object') {
-      registerTsCompiler = typescript.enabled === true || typescript.enabled === undefined
-    }
+    if (typeof outDir === 'undefined') {
+      try {
+        outDir = JSON.parse(await readFile(join(this.dirname, tsConfigFile), 'utf8')).compilerOptions.outDir
+      } catch {
+        // No-op
+      }
 
-    if (registerTsCompiler) {
-      app.register(setupTsCompiler, { context: opts.context })
+      outDir ||= 'dist'
     }
-    app.register(loadPlugins, { context: opts.context })
-  }
 
-  if (isKeyEnabled('cors', config.server)) {
-    app.register(setupCors, config.server.cors)
+    config.watch.ignore ??= []
+    config.watch.ignore.push(outDir + '/**/*')
   }
 
-  if (isKeyEnabled('healthCheck', config.server)) {
-    app.register(setupHealthCheck, config.server.healthCheck)
-  }
+  return config
 }
 
-platformaticService[Symbol.for('skip-override')] = true
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'service')
 
-module.exports.configManagerConfig = {
-  version,
-  schema,
-  allowToWatch: ['.env'],
-  schemaOptions: {
-    useDefaults: true,
-    coerceTypes: true,
-    allErrors: true,
-    strict: false
-  },
-  async transformConfig () {
-    // Set watch to true by default. This is not possible
-    // to do in the schema, because it is uses an anyOf.
-    if (this.current.watch === undefined) {
-      this.current.watch = { enabled: false }
-    }
-
-    if (typeof this.current.watch !== 'object') {
-      this.current.watch = { enabled: this.current.watch || false }
-    }
-
-    const typescript = this.current.plugins?.typescript
-    if (typescript) {
-      let outDir = typescript.outDir
-      if (outDir === undefined) {
-        let tsConfigFile = typescript.tsConfigFile || 'tsconfig.json'
-        tsConfigFile = join(this.dirname, tsConfigFile)
-        try {
-          const tsConfig = JSON.parse(await readFile(tsConfigFile, 'utf8'))
-          outDir = tsConfig.compilerOptions.outDir
-        } catch {}
-        outDir ||= 'dist'
-      }
-
-      this.current.watch.ignore ||= []
-      this.current.watch.ignore.push(outDir + '/**/*')
-    }
-  },
-  upgrade
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    root,
+    ...context
+  })
 }
 
-platformaticService.configType = 'service'
-platformaticService.schema = schema
-platformaticService.configManagerConfig = module.exports.configManagerConfig
-
-function _buildServer (options, app) {
-  return buildServer(options, app || module.exports)
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new ServiceCapability(config[kMetadata].root, config, context)
 }
 
-async function buildStackable (options, app = platformaticService, Stackable = ServiceStackable) {
-  let configManager = options.configManager
-
-  if (configManager === undefined) {
-    if (typeof options.config === 'string') {
-      ;({ configManager } = await loadConfig(
-        {},
-        ['-c', options.config],
-        app,
-        {
-          onMissingEnv: options.onMissingEnv,
-          context: options.context
-        },
-        true
-      ))
-    } else {
-      configManager = new ConfigManager({
-        ...app.configManagerConfig,
-        source: options.config,
-        dirname: options.context?.directory
-      })
-      await configManager.parseAndValidate()
-    }
-  }
-
-  const stackable = new Stackable({
-    init: () => buildServer({
-      configManager,
-      ...configManager.current,
-    }, app, options.context),
-    stackable: app,
-    configManager,
-    context: options.context
-  })
-
-  return stackable
-}
+export const skipTelemetryHooks = true
 
-module.exports.configType = 'service'
-module.exports.app = platformaticService
-module.exports.schema = schema
-module.exports.buildServer = _buildServer
-module.exports.buildStackable = buildStackable
-module.exports.schemas = require('./lib/schema')
-module.exports.platformaticService = platformaticService
-module.exports.addLoggerToTheConfig = addLoggerToTheConfig
-module.exports.start = start
-module.exports.Generator = ServiceGenerator
-module.exports.ServiceStackable = ServiceStackable
-module.exports.buildCompileCmd = buildCompileCmd
-module.exports.extractTypeScriptCompileOptionsFromConfig = extractTypeScriptCompileOptionsFromConfig
+export { platformaticService } from './lib/application.js'
+export { ServiceCapability } from './lib/capability.js'
+export { applyTestHelperCustomizations, Generator } from './lib/generator.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'

package/lib/application.js

@@ -0,0 +1,35 @@
+import { isKeyEnabled } from '@platformatic/foundation'
+import { setupCors } from './plugins/cors.js'
+import { setupGraphQL } from './plugins/graphql.js'
+import { setupHealthCheck } from './plugins/health-check.js'
+import { setupOpenAPI } from './plugins/openapi.js'
+import { loadPlugins } from './plugins/plugins.js'
+
+export async function platformaticService (app, capability) {
+  const config = await capability.getConfig()
+
+  const serviceConfig = config.service || {}
+
+  if (isKeyEnabled('openapi', serviceConfig)) {
+    const openapi = serviceConfig.openapi
+    await app.register(setupOpenAPI, { openapi })
+  }
+
+  if (isKeyEnabled('graphql', serviceConfig)) {
+    await app.register(setupGraphQL, serviceConfig.graphql)
+  }
+
+  if (config.plugins) {
+    await app.register(loadPlugins, capability.context)
+  }
+
+  if (isKeyEnabled('cors', config.server)) {
+    await app.register(setupCors, config.server.cors)
+  }
+
+  if (isKeyEnabled('healthCheck', config.server)) {
+    await app.register(setupHealthCheck, config.server.healthCheck)
+  }
+}
+
+platformaticService[Symbol.for('skip-override')] = true

package/lib/capability.js

@@ -0,0 +1,281 @@
+import { BaseCapability, 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 ServiceCapability extends BaseCapability {
+  #app
+  #basePath
+
+  constructor (root, config, context) {
+    super('service', version, root, config, context)
+    this.applicationFactory = this.context.applicationFactory ?? platformaticService
+  }
+
+  async init () {
+    await super.init()
+
+    if (this.#app) {
+      return
+    }
+
+    const config = this.config
+    this.#basePath = ensureTrailingSlash(cleanBasePath(config.basePath ?? this.applicationId))
+
+    // 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)
+    }
+
+    this.#app.decorate('platformatic', { config: this.config })
+
+    await this.#app.register(this.applicationFactory, this)
+
+    if (Array.isArray(this.context.fastifyPlugins)) {
+      for (const plugin of this.context.fastifyPlugins) {
+        await this.#app.register(plugin)
+      }
+    }
+
+    if (!this.#app.hasRoute({ url: '/', method: 'GET' }) && !this.#app.hasRoute({ url: '/*', method: 'GET' })) {
+      await this.#app.register(setupRoot)
+    }
+  }
+
+  async start (startOptions) {
+    // Compatibility with v2 service
+    const { listen } = startOptions ?? { listen: true }
+
+    // Make this idempotent
+    if (this.url) {
+      return this.url
+    }
+
+    // Create the application if needed
+    if (!this.#app) {
+      await this.init()
+      await this.#app.ready()
+    }
+
+    if (listen) {
+      await this._listen()
+    }
+
+    await this._collectMetrics()
+    return this.url
+  }
+
+  async stop () {
+    await super.stop()
+    await this.#app?.close()
+  }
+
+  async inject (injectParams, onInject) {
+    const response = await this.#app.inject(injectParams, onInject)
+
+    if (onInject) {
+      return
+    }
+
+    const { statusCode, statusMessage, headers, body } = response
+    return { statusCode, statusMessage, headers, body }
+  }
+
+  getApplication () {
+    return this.#app
+  }
+
+  async getDispatchFunc () {
+    await this.init()
+    return this.#app
+  }
+
+  async getConfig (includeMeta = false) {
+    let config = await super.getConfig(includeMeta)
+    const loggerInstance = this.serverConfig?.loggerInstance
+
+    if (loggerInstance) {
+      config = Object.assign({}, config)
+      const { loggerInstance: _, ...serverConfig } = this.serverConfig
+      config.server = { ...serverConfig, logger: { level: loggerInstance.level } }
+    }
+
+    return config
+  }
+
+  async getWatchConfig () {
+    const config = this.config
+
+    const enabled = config.watch?.enabled !== false && config.plugins !== undefined
+
+    if (!enabled) {
+      return { enabled, path: this.root }
+    }
+
+    return {
+      enabled,
+      path: this.root,
+      allow: config.watch?.allow,
+      ignore: config.watch?.ignore
+    }
+  }
+
+  getMeta () {
+    return {
+      gateway: {
+        tcp: typeof this.url !== 'undefined',
+        url: this.url,
+        prefix: this.basePath ?? this.#basePath,
+        wantsAbsoluteUrls: false,
+        needsRootTrailingSlash: false
+      },
+      connectionStrings: [this.connectionString]
+    }
+  }
+
+  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
+  }
+
+  async updateContext (context) {
+    super.updateContext(context)
+
+    this.context = { ...this.context, ...context }
+
+    if (!this.context) {
+      return
+    }
+
+    const { telemetryConfig, serverConfig, isEntrypoint, isProduction, logger } = this.context
+
+    const config = { ...this.config }
+
+    if (telemetryConfig) {
+      config.telemetry = telemetryConfig
+    }
+
+    const loggerInstance = logger ?? serverConfig?.loggerInstance ?? this.serverConfig?.loggerInstance
+
+    if (serverConfig) {
+      config.server = deepmerge(this.serverConfig, serverConfig ?? {})
+    }
+
+    config.server ??= {}
+
+    if (isProduction) {
+      if (config.plugins) {
+        config.plugins.typescript = false
+      }
+      config.watch = { enabled: false }
+    }
+
+    // Adjust server options
+    if (!isEntrypoint) {
+      config.server.trustProxy = true
+    }
+
+    if (config.server.https) {
+      config.server.https.key = await sanitizeHTTPSArgument(config.server.https.key)
+      config.server.https.cert = await sanitizeHTTPSArgument(config.server.https.cert)
+    }
+
+    // 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
+  }
+
+  _initializeLogger () {
+    if (this.context?.logger) {
+      return this.context.logger
+    } else if (this.config.server?.loggerInstance) {
+      return this.config.server?.loggerInstance
+    }
+
+    this.serverConfig ??= {}
+    this.loggerConfig = deepmerge(this.context.loggerConfig ?? {}, this.serverConfig?.logger ?? {})
+
+    const pinoOptions = {
+      ...(this.loggerConfig ?? {}),
+      level: this.loggerConfig?.level ?? 'trace'
+    }
+
+    this.registerGlobals({
+      logLevel: pinoOptions.level
+    })
+
+    if (this.context?.applicationId) {
+      pinoOptions.name = this.context.applicationId
+    }
+
+    if (this.context?.worker?.count > 1 && this.loggerConfig?.base !== null) {
+      pinoOptions.base = { pid: process.pid, hostname: hostname(), worker: this.context.worker.index }
+    } else if (this.loggerConfig?.base === null) {
+      pinoOptions.base = undefined
+    }
+
+    if (this.loggerConfig?.formatters) {
+      pinoOptions.formatters = buildPinoFormatters(this.loggerConfig?.formatters)
+    }
+    if (this.loggerConfig?.timestamp) {
+      pinoOptions.timestamp = buildPinoTimestamp(this.loggerConfig?.timestamp)
+    }
+
+    const logger = pino(pinoOptions)
+
+    // Only one of logger and loggerInstance should be set
+    this.serverConfig.loggerInstance = logger
+    delete this.serverConfig.logger
+
+    return logger
+  }
+
+  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
+  }
+}