@platformatic/service 2.72.0 → 3.0.0-alpha.1

package/config.d.ts

@@ -5,7 +5,7 @@
  * and run json-schema-to-typescript to regenerate this file.
  */
 
-export interface PlatformaticService {
+export interface PlatformaticServiceConfig {
   basePath?: string;
   server?: {
     hostname?: string;
@@ -164,24 +164,6 @@ export interface PlatformaticService {
   plugins?: {
     [k: string]: unknown;
   };
-  metrics?:
-    | boolean
-    | {
-        port?: number | string;
-        hostname?: string;
-        endpoint?: string;
-        server?: "own" | "parent" | "hide";
-        defaultMetrics?: {
-          enabled: boolean;
-        };
-        auth?: {
-          username: string;
-          password: string;
-        };
-        labels?: {
-          [k: string]: string;
-        };
-      };
   telemetry?: {
     enabled?: boolean | string;
     /**

package/eslint.config.js

@@ -1,14 +1,12 @@
-'use strict'
+import neostandard from 'neostandard'
 
-const neostandard = require('neostandard')
-
-module.exports = neostandard({
+export default neostandard({
   ts: true,
   ignores: [
     ...neostandard.resolveIgnoresFromGitignore(),
     'test/tmp/**/*',
     'test/fixtures/*/dist/**/*',
     '**/dist/*',
-    'fixtures/**/*',
-  ],
+    'tmp/**/*'
+  ]
 })

package/index.d.ts

@@ -1,65 +1,69 @@
-/// <reference types="mercurius" />
-/// <reference types="@fastify/swagger" />
-import { FastifyInstance, FastifyBaseLogger } from 'fastify'
-import ConfigManager from '@platformatic/config'
-import type { Stackable as _Stackable, StackableInterface, ConfigManagerConfig } from '@platformatic/config'
+import { BaseContext, BaseOptions, BaseStackable } from '@platformatic/basic'
 import { BaseGenerator } from '@platformatic/generators'
-import { PlatformaticService } from './config'
-import type { JSONSchemaType } from 'ajv'
-import { ServiceGenerator } from './lib/generator/service-generator'
+import { Configuration, ConfigurationOptions } from '@platformatic/utils'
+import { JSONSchemaType } from 'ajv'
+import { FastifyInstance } from 'fastify'
+import { PlatformaticServiceConfig } from './config'
 
-export import Generator = ServiceGenerator.ServiceGenerator
+export { PlatformaticServiceConfig } from './config'
 
-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 = {}> = Promise<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> | 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<ServiceStackable>
 
-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, stackable: ServiceStackable): Promise<void>
 
-export declare const app: (app: FastifyInstance, opts: object) => Promise<void>
+export declare class Generator extends BaseGenerator.BaseGenerator {}
 
-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>
+  service: JSONSchemaType<object>
+  client: JSONSchemaType<object>
 }
 
-export function buildStackable (opts: { config: string }, app?: object): Promise<StackableInterface>
+export declare const version: string
 
-export default defaultExport
+export declare class ServiceStackable<Config = PlatformaticServiceConfig> extends BaseStackable<
+  Config,
+  BaseOptions<ServiceContext>
+> {
+  constructor (root: string, config: Config, context?: object)
+  getApplication (): FastifyInstance
+}

package/index.js

@@ -1,218 +1,63 @@
-'use strict'
+import { transform as basicTransform, resolve, validationOptions } from '@platformatic/basic'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/utils'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+import { schema } from './lib/schema.js'
+import { ServiceStackable } from './lib/stackable.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('node:fs/promises')
-const { join } = require('node:path')
-const { workerData } = require('node:worker_threads')
-const jsonPatch = require('fast-json-patch')
+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)
+  if (config.server && (await isDocker())) {
+    config.server.hostname = '0.0.0.0'
   }
 
-  // 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)
-  }
+  const typescript = config.plugins?.typescript
 
-  if (Array.isArray(beforePlugins)) {
-    for (const plugin of beforePlugins) {
-      app.register(plugin)
-    }
-  }
+  if (typescript) {
+    let { outDir, tsConfigFile } = typescript
+    tsConfigFile ??= 'tsconfig.json'
 
-  const serviceConfig = config.service || {}
-
-  if (isKeyEnabled('openapi', serviceConfig)) {
-    const openapi = serviceConfig.openapi
-    app.register(setupOpenAPI, { openapi })
-  }
-
-  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
-}
-
-platformaticService.configType = 'service'
-platformaticService.schema = schema
-platformaticService.configManagerConfig = module.exports.configManagerConfig
-
-function _buildServer (options, app, context) {
-  return buildServer(options, app || module.exports, context)
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    root,
+    ...context
+  })
 }
 
-// No-op for now, inserted for future compatibility
-async function createDefaultConfig (opts) {
-  return {}
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new ServiceStackable(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 patch = workerData?.serviceConfig?.configPatch
-
-  if (Array.isArray(patch)) {
-    configManager.current = jsonPatch.applyPatch(configManager.current, patch).newDocument
-  }
-
-  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.isPLTService = true
-module.exports.app = platformaticService
-module.exports.schema = schema
-module.exports.buildServer = _buildServer
-module.exports.buildStackable = buildStackable
-module.exports.createDefaultConfig = createDefaultConfig
-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 { Generator } from './lib/generator.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'
+export { ServiceStackable } from './lib/stackable.js'

package/lib/application.js

@@ -0,0 +1,57 @@
+import { isKeyEnabled } from '@platformatic/utils'
+import { setupClients } from './plugins/clients.js'
+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'
+import { setupTsCompiler } from './plugins/typescript.js'
+
+export async function platformaticService (app, stackable) {
+  const config = await stackable.getConfig()
+
+  // This must be done before loading the plugins, so they can be configured accordingly
+  if (isKeyEnabled('clients', config)) {
+    await app.register(setupClients, config.clients)
+  }
+
+  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) {
+    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 (registerTsCompiler) {
+      await app.register(setupTsCompiler, stackable.context)
+    }
+
+    await app.register(loadPlugins, stackable.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/compile.js

@@ -1,57 +1,6 @@
-'use strict'
-
-const { compile } = require('@platformatic/ts-compiler')
-const { loadConfig } = require('@platformatic/config')
-const pino = require('pino')
-const pretty = require('pino-pretty')
-const { dirname } = require('path')
-
-function buildCompileCmd (app) {
-  return async function compileCmd (_args) {
-    let fullPath = null
-    let config = null
-
-    try {
-      const { configManager } = await loadConfig({}, _args, app, {
-        watch: false
-      })
-      await configManager.parseAndValidate()
-      config = configManager.current
-      fullPath = dirname(configManager.fullPath)
-      /* c8 ignore next 4 */
-    } catch (err) {
-      console.error(err)
-      process.exit(1)
-    }
-
-    const logger = pino(
-      pretty({
-        translateTime: 'SYS:HH:MM:ss',
-        ignore: 'hostname,pid'
-      })
-    )
-
-    try {
-      await compile({
-        ...extractTypeScriptCompileOptionsFromConfig(config),
-        cwd: fullPath,
-        logger,
-        clean: _args.includes('--clean')
-      })
-    } catch (e) {
-      logger.error(e.message)
-      process.exit(1)
-    }
-  }
-}
-
-module.exports.buildCompileCmd = buildCompileCmd
-
-function extractTypeScriptCompileOptionsFromConfig (config) {
+export function getTypescriptCompilationOptions (config) {
   return {
     tsConfig: config.plugins?.typescript?.tsConfig,
     flags: config.plugins?.typescript?.flags
   }
 }
-
-module.exports.extractTypeScriptCompileOptionsFromConfig = extractTypeScriptCompileOptionsFromConfig