@platformatic/composer 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 PlatformaticComposer {
+export interface PlatformaticComposerConfig {
   basePath?: string;
   server?: {
     hostname?: string;
@@ -367,24 +367,6 @@ export interface PlatformaticComposer {
     addEmptySchema?: boolean;
     refreshTimeout?: number;
   };
-  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;
-        };
-      };
   types?: {
     autogenerate?: boolean;
     /**

package/eslint.config.js

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

package/index.d.ts

@@ -1,17 +1,58 @@
-import { FastifyInstance } from 'fastify'
-import ConfigManager from '@platformatic/config'
-import type { ConfigManagerConfig, StackableInterface } from '@platformatic/config'
-import { PlatformaticComposer } from './config'
-
-export { PlatformaticApp } from '@platformatic/service'
-export type PlatformaticComposerConfig = PlatformaticComposer
-
-export function buildServer (opts: object, app?: object, ConfigManagerContructor?: object): Promise<FastifyInstance>
-
-export function buildStackable (opts: object, app?: object): Promise<{
-  configType: string,
-  configManager?: ConfigManager<PlatformaticComposerConfig>,
-  configManagerConfig?: ConfigManagerConfig<PlatformaticComposerConfig>,
-  schema?: object,
-  stackable?: StackableInterface
-}>
+import { BaseStackable } from '@platformatic/basic'
+import { BaseGenerator } from '@platformatic/generators'
+import {
+  Configuration,
+  ConfigurationOptions,
+  ServerInstance as ServiceInstance,
+  ServiceStackable
+} from '@platformatic/service'
+import { JSONSchemaType } from 'ajv'
+import { FastifyError, FastifyInstance } from 'fastify'
+import { PlatformaticComposerConfig } from './config'
+
+export { PlatformaticApplication } from '@platformatic/service'
+export { PlatformaticComposerConfig } from './config'
+
+export type ComposerStackable = ServiceStackable<PlatformaticComposerConfig>
+
+export type ServerInstance = ServiceInstance<PlatformaticComposerConfig>
+
+type ComposerConfiguration = Configuration<PlatformaticComposerConfig>
+
+export declare function loadConfiguration (
+  root: string | PlatformaticServiceConfig,
+  source?: string | PlatformaticServiceConfig,
+  context?: ConfigurationOptions
+): Promise<ComposerConfiguration>
+
+export function create (
+  root: string,
+  source?: string | PlatformaticComposerConfig,
+  context?: ConfigurationOptions
+): Promise<ComposerStackable>
+
+export declare function platformaticComposer (app: FastifyInstance, stackable: BaseStackable): Promise<void>
+
+export class Generator extends BaseGenerator.BaseGenerator {}
+
+export declare const packageJson: Record<string, unknown>
+
+export declare const schema: JSONSchemaType<PlatformaticComposerConfig>
+
+export declare const schemaComponents: {
+  openApiService: JSONSchemaType<object>
+  entityResolver: JSONSchemaType<object>
+  entities: JSONSchemaType<object>
+  graphqlService: JSONSchemaType<object>
+  graphqlComposerOptions: JSONSchemaType<object>
+  composer: JSONSchemaType<object>
+  types: JSONSchemaType<object>
+}
+
+export declare const version: string
+
+export function FastifyInstanceIsAlreadyListeningError (): FastifyError
+export function FailedToFetchOpenAPISchemaError (): FastifyError
+export function ValidationErrors (): FastifyError
+export function PathAlreadyExistsError (): FastifyError
+export function CouldNotReadOpenAPIConfigError (): FastifyError

package/index.js

@@ -1,217 +1,34 @@
-'use strict'
-
-const deepEqual = require('fast-deep-equal')
-const ConfigManager = require('@platformatic/config')
-const { platformaticService, buildServer, buildStackable } = require('@platformatic/service')
-const { isKeyEnabled } = require('@platformatic/utils')
-
-const { schema } = require('./lib/schema')
-const serviceProxy = require('./lib/proxy')
-const graphql = require('./lib/graphql')
-const composerHook = require('./lib/composer-hook')
-const { openApiGenerator, openApiComposer } = require('./lib/openapi-generator')
-const graphqlGenerator = require('./lib/graphql-generator')
-const { isSameGraphqlSchema, fetchGraphqlSubgraphs } = require('./lib/graphql-fetch')
-const notHostConstraints = require('./lib/proxy/not-host-constraints')
-const { isFetchable } = require('./lib/utils')
-const { ComposerStackable, ensureServices } = require('./lib/stackable')
-const errors = require('./lib/errors')
-const upgrade = require('./lib/upgrade')
-
-const EXPERIMENTAL_GRAPHQL_COMPOSER_FEATURE_MESSAGE = 'graphql composer is an experimental feature'
-
-async function platformaticComposer (app, opts) {
-  const configManager = app.platformatic.configManager
-  const config = configManager.current
-  let hasGraphqlServices, hasOpenapiServices
-
-  // When no services are specified, get the list from the runtime.
-  await ensureServices(opts.context?.stackable?.serviceId, config)
-
-  const { services } = configManager.current.composer
-
-  for (const service of services) {
-    if (!service.origin) {
-      service.origin = `http://${service.id}.plt.local`
-    }
-    if (service.openapi && !hasOpenapiServices) {
-      hasOpenapiServices = true
-    }
-    if (service.graphql && !hasGraphqlServices) {
-      hasGraphqlServices = true
-    }
-  }
-
-  await app.register(composerHook)
-
-  let generatedComposedOpenAPI = null
-  if (hasOpenapiServices) {
-    generatedComposedOpenAPI = await openApiGenerator(app, config.composer)
-  }
-
-  if (isKeyEnabled('healthCheck', config.server)) {
-    if (typeof config.server.healthCheck !== 'object') {
-      config.server.healthCheck = {}
-    }
-
-    const stackable = opts.context.stackable
-    config.server.healthCheck.fn = stackable.isHealthy.bind(stackable)
-  }
-
-  app.register(serviceProxy, { ...config.composer, context: opts.context })
-  await app.register(platformaticService, { config: { ...config, openapi: false }, context: opts.context })
-
-  if (generatedComposedOpenAPI) {
-    await app.register(openApiComposer, { opts: config.composer, generated: generatedComposedOpenAPI })
-  }
-
-  if (hasGraphqlServices) {
-    app.log.warn(EXPERIMENTAL_GRAPHQL_COMPOSER_FEATURE_MESSAGE)
-    app.register(graphql, config.composer)
-    await app.register(graphqlGenerator, config.composer)
-  }
-
-  if (!app.hasRoute({ url: '/', method: 'GET' }) && !app.hasRoute({ url: '/*', method: 'GET' })) {
-    await app.register(require('./lib/root-endpoint'), config)
-  }
-
-  if (!opts.context?.isProduction) {
-    await watchServices(app, config)
-  }
-}
-
-platformaticComposer[Symbol.for('skip-override')] = true
-platformaticComposer.schema = schema
-platformaticComposer.configType = 'composer'
-platformaticComposer.isPLTService = true
-platformaticComposer.configManagerConfig = {
-  version: require('./package.json').version,
-  schema,
-  allowToWatch: ['.env'],
-  schemaOptions: {
-    useDefaults: true,
-    coerceTypes: true,
-    allErrors: true,
-    strict: false
-  },
-  transformConfig: platformaticService.configManagerConfig.transformConfig,
-  upgrade
-}
-
-// TODO review no need to be async
-async function buildComposerServer (options) {
-  // TODO ConfigManager is not been used, it's attached to platformaticComposer, can be removed
-  return buildServer(options, platformaticComposer, ConfigManager)
-}
-
-async function detectServicesUpdate ({ app, services, fetchOpenApiSchema, fetchGraphqlSubgraphs }) {
-  let changed
-
-  const graphqlServices = []
-  // assumes services here are fetchable
-  for (const service of services) {
-    const { id, origin, openapi, graphql } = service
-
-    if (openapi) {
-      const currentSchema = app.openApiSchemas.find(schema => schema.id === id)?.originSchema || null
-
-      let fetchedSchema = null
-      try {
-        fetchedSchema = await fetchOpenApiSchema({ origin, openapi })
-      } catch (err) {
-        app.log.error({ err }, 'failed to fetch schema (watch) for service ' + id)
-      }
-
-      if (!changed && !deepEqual(fetchedSchema, currentSchema)) {
-        changed = true
-        // it stops at first schema difference since all the schemas will be updated on reload
-        break
-      }
-    }
-
-    if (graphql) {
-      graphqlServices.push(service)
-    }
-  }
-
-  if (!changed && graphqlServices.length > 0) {
-    const graphqlSupergraph = await fetchGraphqlSubgraphs(graphqlServices, app.graphqlComposerOptions, app)
-    if (!isSameGraphqlSchema(graphqlSupergraph, app.graphqlSupergraph)) {
-      changed = true
-      app.graphqlSupergraph = graphqlSupergraph
-    }
-  }
-
-  return changed
-}
-
-/**
- * poll services to detect changes, every `opts.composer.refreshTimeout`
- * polling is disabled on refreshTimeout = 0
- * or there are no network openapi nor graphql remote services (the services are from file or they don't have a schema/graph to fetch)
- */
-async function watchServices (app, opts) {
-  const { services, refreshTimeout } = opts.composer
-  if (refreshTimeout < 1) {
-    return
-  }
-
-  const watching = services.filter(isFetchable)
-  if (watching.length < 1) {
-    return
-  }
-
-  if (!globalThis[Symbol.for('plt.runtime.id')]) {
-    app.log.warn('Watching services is only supported when running within a Platformatic Runtime.')
-    return
-  }
-
-  const { fetchOpenApiSchema } = await import('./lib/openapi-fetch-schemas.mjs')
-
-  app.log.info({ services: watching }, 'start watching services')
-
-  const timer = setInterval(async () => {
-    try {
-      if (await detectServicesUpdate({ app, services: watching, fetchOpenApiSchema, fetchGraphqlSubgraphs })) {
-        clearInterval(timer)
-        app.log.info('detected services changes, restarting ...')
-
-        globalThis[Symbol.for('plt.runtime.itc')].notify('changed')
-      }
-    } catch (error) {
-      app.log.error(
-        {
-          err: {
-            message: error.message,
-            stack: error.stack
-          }
-        },
-        'failed to get services info'
-      )
-    }
-  }, refreshTimeout).unref()
-
-  app.addHook('onClose', async () => {
-    clearInterval(timer)
+import { resolve, validationOptions } from '@platformatic/basic'
+import { transform } from '@platformatic/service'
+import { kMetadata, loadConfiguration as utilsLoadConfiguration } from '@platformatic/utils'
+import { schema } from './lib/schema.js'
+import { ComposerStackable } from './lib/stackable.js'
+import { upgrade } from './lib/upgrade.js'
+
+export async function loadConfiguration (configOrRoot, sourceOrConfig, context) {
+  const { root, source } = await resolve(configOrRoot, sourceOrConfig, 'composer')
+
+  return utilsLoadConfiguration(source, context?.schema ?? schema, {
+    validationOptions,
+    transform,
+    upgrade,
+    replaceEnv: true,
+    root,
+    ...context
   })
 }
 
-async function buildComposerStackable (options) {
-  options.context ??= {}
-  options.context.fastifyOptions ??= {
-    constraints: {
-      notHost: notHostConstraints
-    }
-  }
-
-  return buildStackable(options, platformaticComposer, ComposerStackable)
+export async function create (configOrRoot, sourceOrConfig, context) {
+  const config = await loadConfiguration(configOrRoot, sourceOrConfig, context)
+  return new ComposerStackable(config[kMetadata].root, config, context)
 }
 
-module.exports = platformaticComposer
-module.exports.schema = schema
-module.exports.platformaticComposer = platformaticComposer
-module.exports.buildServer = buildComposerServer
-module.exports.errors = errors
-module.exports.Generator = require('./lib/generator/composer-generator')
-module.exports.ConfigManager = ConfigManager
-module.exports.buildStackable = buildComposerStackable
+export const skipTelemetryHooks = true
+
+export { platformaticComposer } from './lib/application.js'
+export * from './lib/commands/index.js'
+export * from './lib/errors.js'
+export * as errors from './lib/errors.js'
+export { Generator } from './lib/generator.js'
+export { packageJson, schema, schemaComponents, version } from './lib/schema.js'
+export { ComposerStackable } from './lib/stackable.js'

package/lib/application.js

@@ -0,0 +1,186 @@
+import { platformaticService } from '@platformatic/service'
+import { isKeyEnabled } from '@platformatic/utils'
+import deepEqual from 'fast-deep-equal'
+import { fetchOpenApiSchema } from './commands/openapi-fetch-schemas.js'
+import { composerHook } from './composer-hook.js'
+import { fetchGraphqlSubgraphs, isSameGraphqlSchema } from './graphql-fetch.js'
+import { graphqlGenerator } from './graphql-generator.js'
+import { graphql } from './graphql.js'
+import { openApiComposer, openApiGenerator } from './openapi-generator.js'
+import { proxy } from './proxy.js'
+import { isFetchable } from './utils.js'
+
+const kITC = Symbol.for('plt.runtime.itc')
+const EXPERIMENTAL_GRAPHQL_COMPOSER_FEATURE_MESSAGE = 'graphql composer is an experimental feature'
+
+async function detectServicesUpdate ({ app, services, fetchOpenApiSchema, fetchGraphqlSubgraphs }) {
+  let changed
+
+  const graphqlServices = []
+  // assumes services here are fetchable
+  for (const service of services) {
+    const { id, origin, openapi, graphql } = service
+
+    if (openapi) {
+      const currentSchema = app.openApiSchemas.find(schema => schema.id === id)?.originSchema || null
+
+      let fetchedSchema = null
+      try {
+        fetchedSchema = await fetchOpenApiSchema({ origin, openapi })
+      } catch (err) {
+        app.log.error({ err }, 'failed to fetch schema (watch) for service ' + id)
+      }
+
+      if (!changed && !deepEqual(fetchedSchema, currentSchema)) {
+        changed = true
+        // it stops at first schema difference since all the schemas will be updated on reload
+        break
+      }
+    }
+
+    if (graphql) {
+      graphqlServices.push(service)
+    }
+  }
+
+  if (!changed && graphqlServices.length > 0) {
+    const graphqlSupergraph = await fetchGraphqlSubgraphs(graphqlServices, app.graphqlComposerOptions, app)
+    if (!isSameGraphqlSchema(graphqlSupergraph, app.graphqlSupergraph)) {
+      changed = true
+      app.graphqlSupergraph = graphqlSupergraph
+    }
+  }
+
+  return changed
+}
+
+/**
+ * poll services to detect changes, every `opts.composer.refreshTimeout`
+ * polling is disabled on refreshTimeout = 0
+ * or there are no network openapi nor graphql remote services (the services are from file or they don't have a schema/graph to fetch)
+ */
+async function watchServices (app, { config, stackable }) {
+  const { services, refreshTimeout } = config.composer
+  if (refreshTimeout < 1) {
+    return
+  }
+
+  const watching = services.filter(isFetchable)
+  if (watching.length < 1) {
+    return
+  }
+
+  if (!globalThis[Symbol.for('plt.runtime.id')]) {
+    app.log.warn('Watching services is only supported when running within a Platformatic Runtime.')
+    return
+  }
+
+  stackable.emit('watch:start')
+  app.log.info({ services: watching }, 'start watching services')
+
+  const timer = setInterval(async () => {
+    try {
+      if (await detectServicesUpdate({ app, services: watching, fetchOpenApiSchema, fetchGraphqlSubgraphs })) {
+        clearInterval(timer)
+        app.log.info('detected services changes, restarting ...')
+
+        globalThis[Symbol.for('plt.runtime.itc')].notify('changed')
+      }
+    } catch (error) {
+      app.log.error(
+        {
+          err: {
+            message: error.message,
+            stack: error.stack
+          }
+        },
+        'failed to get services info'
+      )
+    }
+  }, refreshTimeout).unref()
+
+  app.addHook('onClose', async () => {
+    clearInterval(timer)
+  })
+}
+
+export async function ensureServices (composerId, config) {
+  if (config.composer?.services?.length) {
+    return
+  }
+
+  composerId ??= globalThis.platformatic?.serviceId
+  config.composer ??= {}
+  config.composer.services ??= []
+
+  // When no services are defined, all services are exposed in the composer
+  const services = await globalThis[kITC]?.send('listServices')
+
+  if (services) {
+    config.composer.services = services
+      .filter(id => id !== composerId) // Remove ourself
+      .map(id => ({ id, proxy: { prefix: `/${id}` } }))
+  }
+}
+
+export async function platformaticComposer (app, stackable) {
+  const config = await stackable.getConfig()
+  let hasGraphqlServices, hasOpenapiServices
+
+  // When no services are specified, get the list from the runtime.
+  await ensureServices(stackable.serviceId, config)
+
+  const { services } = config.composer
+
+  for (const service of services) {
+    if (!service.origin) {
+      service.origin = `http://${service.id}.plt.local`
+    }
+    if (service.openapi && !hasOpenapiServices) {
+      hasOpenapiServices = true
+    }
+    if (service.graphql && !hasGraphqlServices) {
+      hasGraphqlServices = true
+    }
+  }
+
+  await app.register(composerHook)
+
+  let generatedComposedOpenAPI = null
+  if (hasOpenapiServices) {
+    generatedComposedOpenAPI = await openApiGenerator(app, config.composer)
+  }
+
+  if (isKeyEnabled('healthCheck', config.server)) {
+    if (typeof config.server.healthCheck !== 'object') {
+      config.server.healthCheck = {}
+    }
+
+    config.server.healthCheck.fn = stackable.isHealthy.bind(stackable)
+  }
+
+  await app.register(proxy, { ...config.composer, stackable, context: stackable.context })
+
+  await platformaticService(app, stackable)
+
+  if (generatedComposedOpenAPI) {
+    await app.register(openApiComposer, { opts: config.composer, generated: generatedComposedOpenAPI })
+  }
+
+  if (hasGraphqlServices) {
+    app.log.warn(EXPERIMENTAL_GRAPHQL_COMPOSER_FEATURE_MESSAGE)
+    app.register(graphql, config.composer)
+    await app.register(graphqlGenerator, config.composer)
+  }
+
+  if (!app.hasRoute({ url: '/', method: 'GET' }) && !app.hasRoute({ url: '/*', method: 'GET' })) {
+    const rootHandler = await import('./root.js')
+    await app.register(rootHandler.default, config)
+  }
+
+  if (!stackable.context?.isProduction) {
+    await watchServices(app, { config, stackable, context: stackable.context })
+  }
+}
+
+platformaticComposer[Symbol.for('skip-override')] = true

package/lib/commands/index.js

@@ -0,0 +1,15 @@
+import { fetchOpenApiSchemas } from './openapi-fetch-schemas.js'
+
+export function createCommands (id) {
+  return {
+    commands: {
+      [`${id}:fetch-openapi-schemas`]: fetchOpenApiSchemas
+    },
+    help: {
+      [`${id}:fetch-openapi-schemas`]: {
+        usage: `${id}:fetch-openapi-schemas`,
+        description: 'Fetch OpenAPI schemas from remote services'
+      }
+    }
+  }
+}

package/lib/commands/openapi-fetch-schemas.js

@@ -0,0 +1,47 @@
+import { loadConfiguration } from '@platformatic/utils'
+import { writeFile } from 'node:fs/promises'
+import { request } from 'undici'
+import { FailedToFetchOpenAPISchemaError } from '../errors.js'
+import { schema } from '../schema.js'
+import { prefixWithSlash } from '../utils.js'
+
+export async function fetchOpenApiSchema (service) {
+  const { origin, openapi } = service
+
+  const openApiUrl = origin + prefixWithSlash(openapi.url)
+  const { statusCode, body } = await request(openApiUrl)
+
+  if (statusCode !== 200 && statusCode !== 201) {
+    throw new FailedToFetchOpenAPISchemaError(openApiUrl)
+  }
+  const schema = await body.json()
+
+  if (openapi.file !== undefined) {
+    await writeFile(openapi.file, JSON.stringify(schema, null, 2))
+  }
+
+  return schema
+}
+
+export async function fetchOpenApiSchemas (logger, configFile, _args, { colorette }) {
+  const { bold } = colorette
+  const config = await loadConfiguration(configFile, schema)
+  const { services } = config.composer
+
+  const servicesWithValidOpenApi = services.filter(({ openapi }) => openapi && openapi.url && openapi.file)
+
+  const fetchOpenApiRequests = servicesWithValidOpenApi.map(service => fetchOpenApiSchema(service))
+
+  const fetchOpenApiResults = await Promise.allSettled(fetchOpenApiRequests)
+
+  logger.info('Fetching schemas for all services.')
+
+  fetchOpenApiResults.forEach((result, index) => {
+    const serviceId = servicesWithValidOpenApi[index].id
+    if (result.status === 'rejected') {
+      logger.error(`Failed to fetch OpenAPI schema for service with id ${bold(serviceId)}: ${result.reason}`)
+    } else {
+      logger.info(`Successfully fetched OpenAPI schema for service with id ${bold(serviceId)}`)
+    }
+  })
+}

package/lib/composer-hook.js

@@ -1,13 +1,13 @@
-'use strict'
+import fp from 'fastify-plugin'
+import rfdc from 'rfdc'
+import { FastifyInstanceIsAlreadyListeningError } from './errors.js'
 
-const deepClone = require('rfdc')()
-const fp = require('fastify-plugin')
-const errors = require('./errors')
+const deepClone = rfdc()
 
-async function composeOpenAPI (app) {
+async function composerHookPlugin (app) {
   const onRoutesHooks = {}
 
-  app.addHook('onRoute', (routeOptions) => {
+  app.addHook('onRoute', routeOptions => {
     if (routeOptions.schema) {
       routeOptions.schema = deepClone(routeOptions.schema)
     }
@@ -31,7 +31,7 @@ async function composeOpenAPI (app) {
   function addComposerOnRouteHook (openApiPath, methods, hook) {
     /* c8 ignore next 5 */
     if (isApplicationReady) {
-      throw new errors.FastifyInstanceIsAlreadyListeningError()
+      throw new FastifyInstanceIsAlreadyListeningError()
     }
 
     if (onRoutesHooks[openApiPath] === undefined) {
@@ -53,8 +53,8 @@ async function composeOpenAPI (app) {
   Object.defineProperty(app.platformatic, 'addComposerOnRouteHook', {
     value: addComposerOnRouteHook,
     writable: false,
-    configurable: false,
+    configurable: false
   })
 }
 
-module.exports = fp(composeOpenAPI)
+export const composerHook = fp(composerHookPlugin)