@platformatic/composer 3.0.0-alpha.4 → 3.0.0-alpha.6

package/lib/application.js

@@ -1,186 +0,0 @@
-import { isKeyEnabled } from '@platformatic/foundation'
-import { platformaticService } from '@platformatic/service'
-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

@@ -1,15 +0,0 @@
-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

@@ -1,47 +0,0 @@
-import { loadConfiguration } from '@platformatic/foundation'
-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,60 +0,0 @@
-import fp from 'fastify-plugin'
-import rfdc from 'rfdc'
-import { FastifyInstanceIsAlreadyListeningError } from './errors.js'
-
-const deepClone = rfdc()
-
-async function composerHookPlugin (app) {
-  const onRoutesHooks = {}
-
-  app.addHook('onRoute', routeOptions => {
-    if (routeOptions.schema) {
-      routeOptions.schema = deepClone(routeOptions.schema)
-    }
-
-    const method = routeOptions.method
-    const openApiPath = routeOptions.config?.openApiPath
-
-    const onRouteHooks = onRoutesHooks[openApiPath]?.[method]
-    if (Array.isArray(onRouteHooks)) {
-      for (const onRouteHook of onRouteHooks) {
-        onRouteHook(routeOptions)
-      }
-    }
-  })
-
-  let isApplicationReady = false
-  app.addHook('onReady', () => {
-    isApplicationReady = true
-  })
-
-  function addComposerOnRouteHook (openApiPath, methods, hook) {
-    /* c8 ignore next 5 */
-    if (isApplicationReady) {
-      throw new FastifyInstanceIsAlreadyListeningError()
-    }
-
-    if (onRoutesHooks[openApiPath] === undefined) {
-      onRoutesHooks[openApiPath] = {}
-    }
-
-    const routeHooks = onRoutesHooks[openApiPath]
-
-    for (let method of methods) {
-      method = method.toUpperCase()
-
-      if (routeHooks[method] === undefined) {
-        routeHooks[method] = []
-      }
-      routeHooks[method].push(hook)
-    }
-  }
-
-  Object.defineProperty(app.platformatic, 'addComposerOnRouteHook', {
-    value: addComposerOnRouteHook,
-    writable: false,
-    configurable: false
-  })
-}
-
-export const composerHook = fp(composerHookPlugin)

package/lib/errors.js

@@ -1,18 +0,0 @@
-import createError from '@fastify/error'
-
-const ERROR_PREFIX = 'PLT_COMPOSER'
-
-export const FastifyInstanceIsAlreadyListeningError = createError(
-  `${ERROR_PREFIX}_FASTIFY_INSTANCE_IS_ALREADY_LISTENING`,
-  'Fastify instance is already listening. Cannot call "addComposerOnRouteHook"!'
-)
-export const FailedToFetchOpenAPISchemaError = createError(
-  `${ERROR_PREFIX}_FAILED_TO_FETCH_OPENAPI_SCHEMA`,
-  'Failed to fetch OpenAPI schema from %s'
-)
-export const ValidationErrors = createError(`${ERROR_PREFIX}_VALIDATION_ERRORS`, 'Validation errors: %s')
-export const PathAlreadyExistsError = createError(`${ERROR_PREFIX}_PATH_ALREADY_EXISTS`, 'Path "%s" already exists')
-export const CouldNotReadOpenAPIConfigError = createError(
-  `${ERROR_PREFIX}_COULD_NOT_READ_OPENAPI_CONFIG`,
-  'Could not read openapi config for "%s" service'
-)

package/lib/generator.js

@@ -1,127 +0,0 @@
-import { Generator as ServiceGenerator } from '@platformatic/service'
-
-export class Generator extends ServiceGenerator {
-  constructor (opts) {
-    super({
-      ...opts,
-      module: '@platformatic/composer'
-    })
-  }
-
-  getDefaultConfig () {
-    const defaultBaseConfig = super.getDefaultConfig()
-
-    return {
-      ...defaultBaseConfig,
-      plugin: false,
-      routes: false,
-      tests: false
-    }
-  }
-
-  async _beforePrepare () {
-    if (this.config.isUpdating) {
-      return
-    }
-
-    await super._beforePrepare()
-
-    this.addEnvVars(
-      {
-        PLT_EXAMPLE_ORIGIN: 'http://127.0.0.1:3043'
-      },
-      { overwrite: false, default: true }
-    )
-
-    this.config.dependencies = {
-      '@platformatic/composer': `^${this.platformaticVersion}`
-    }
-  }
-
-  async _afterPrepare () {
-    if (this.config.isUpdating) {
-      return
-    }
-
-    await super._afterPrepare()
-    const PLT_ENVIRONMENT_TEMPLATE = `
-import { type FastifyInstance } from 'fastify'
-import { PlatformaticApplication, PlatformaticComposerConfig } from '@platformatic/composer'
-
-declare module 'fastify' {
-  interface FastifyInstance {
-    platformatic: PlatformaticApplication<PlatformaticComposerConfig>
-  }
-}
-`
-
-    const README = `
-# Platformatic Composer API
-
-This is a generated [Platformatic Composer](https://docs.platformatic.dev/docs/composer/overview) application.
-
-## Requirements
-
-Platformatic supports macOS, Linux and Windows ([WSL](https://docs.microsoft.com/windows/wsl/) recommended).
-You'll need to have [Node.js](https://nodejs.org/) >= v18.8.0 or >= v20.6.0
-
-## Setup
-
-1. Install dependencies:
-
-\`\`\`bash
-npm install
-\`\`\`
-
-## Usage
-
-Run the API with:
-
-\`\`\`bash
-npm start
-\`\`\`
-
-### Explore
-- ⚡ The Platformatic Composer server is running at http://localhost:3042/
-- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/      
-`
-
-    this.addFile({ path: '', file: 'plt-env.d.ts', contents: PLT_ENVIRONMENT_TEMPLATE })
-    this.addFile({ path: '', file: 'README.md', contents: README })
-  }
-
-  async _getConfigFileContents () {
-    const config = await super._getConfigFileContents()
-    delete config.service
-    config.$schema = `https://schemas.platformatic.dev/@platformatic/composer/${this.platformaticVersion}.json`
-
-    config.composer = {
-      services: [
-        {
-          id: 'example',
-          origin: `{${this.getEnvVarName('PLT_EXAMPLE_ORIGIN')}}`,
-          openapi: {
-            url: '/documentation/json'
-          }
-        }
-      ],
-      refreshTimeout: 1000
-    }
-
-    if (this.runtime !== null) {
-      config.composer.services = this.runtime.services
-        .filter(serviceMeta => serviceMeta.service.module !== '@platformatic/composer')
-        .map(serviceMeta => {
-          return {
-            id: serviceMeta.name,
-            openapi: {
-              url: '/documentation/json',
-              prefix: `/${serviceMeta.name}`
-            }
-          }
-        })
-    }
-
-    return config
-  }
-}

package/lib/graphql-fetch.js

@@ -1,83 +0,0 @@
-import { compose } from '@platformatic/graphql-composer'
-
-const placeholderSdl = 'Query { _info: String }'
-const placeholderResolvers = { Query: { _info: '@platformatic/composer' } }
-
-// TODO support subscriptions
-// const defaultSubscriptionsOptions = {
-//   onError: function onComposerSubscriptionsError (ctx, topic, err) {
-//     // TODO log.error({err})
-//     throw err
-//   },
-//   publish (ctx, topic, payload) {
-//     ctx.pubsub.publish({ topic, payload })
-//   },
-//   subscribe (ctx, topic) {
-//     return ctx.pubsub.subscribe(topic)
-//   },
-//   unsubscribe (ctx, topic) {
-//     ctx.pubsub.close()
-//   }
-// }
-
-function toComposerOptions (options, app) {
-  return {
-    logger: app.log,
-    defaultArgsAdapter: options?.defaultArgsAdapter,
-    addEntitiesResolvers: options?.addEntitiesResolvers,
-    entities: options?.entities,
-    onSubgraphError: (err, subgraphName) => {
-      app.log.error({ err }, 'graphql composer error on subgraph ' + subgraphName)
-
-      if (options?.onSubgraphError) {
-        try {
-          options.onSubgraphError(err, subgraphName)
-        } catch (err) {
-          app.log.error({ err }, 'running onSubgraphError')
-        }
-      }
-    }
-  }
-}
-
-export function createSupergraph ({ sdl = null, resolvers = {} } = {}) {
-  // in case of temporary failures of subgraphs on watching, the service can restart if no subgraphs are (tempoary) available
-  if (!sdl) {
-    return {
-      sdl: placeholderSdl,
-      resolvers: placeholderResolvers
-    }
-  }
-  return { sdl, resolvers }
-}
-
-export function isSameGraphqlSchema (a, b) {
-  // TODO review
-  return a?.sdl === b?.sdl
-}
-
-export function serviceToSubgraphConfig (service) {
-  if (!service.graphql) {
-    return
-  }
-  return {
-    name: service.graphql.name || service.id || service.origin,
-    entities: service.graphql.entities,
-    server: {
-      host: service.graphql.host || service.origin,
-      composeEndpoint: service.graphql.composeEndpoint,
-      graphqlEndpoint: service.graphql.graphqlEndpoint
-    }
-  }
-}
-
-export async function fetchGraphqlSubgraphs (services, options, app) {
-  const subgraphs = services.map(serviceToSubgraphConfig).filter(s => !!s)
-  const composer = await compose({ ...toComposerOptions(options, app), subgraphs })
-
-  return createSupergraph({
-    logger: app.log,
-    sdl: composer.toSdl(),
-    resolvers: composer.resolvers
-  })
-}

package/lib/graphql-generator.js

@@ -1,33 +0,0 @@
-import fp from 'fastify-plugin'
-import mercurius from 'mercurius'
-import { fetchGraphqlSubgraphs } from './graphql-fetch.js'
-
-async function graphqlGeneratorPlugin (app, opts) {
-  if (!opts.services.some(s => s.graphql)) {
-    return
-  }
-
-  const services = []
-
-  for (const service of opts.services) {
-    if (!service.graphql) {
-      continue
-    }
-    services.push(service)
-  }
-
-  const graphqlConfig = {
-    graphiql: opts.graphql?.graphiql
-  }
-  if (services.length > 0) {
-    const graphqlSupergraph = await fetchGraphqlSubgraphs(services, opts.graphql, app)
-    graphqlConfig.schema = graphqlSupergraph.sdl
-    graphqlConfig.resolvers = graphqlSupergraph.resolvers
-    graphqlConfig.subscription = false // TODO support subscriptions, will be !!opts.graphql.subscriptions
-    app.graphqlSupergraph = graphqlSupergraph
-  }
-
-  await app.register(mercurius, graphqlConfig)
-}
-
-export const graphqlGenerator = fp(graphqlGeneratorPlugin)

package/lib/graphql.js

@@ -1,24 +0,0 @@
-import fp from 'fastify-plugin'
-import { createSupergraph } from './graphql-fetch.js'
-
-const graphqlSupergraphSymbol = Symbol('graphqlSupergraph')
-
-export async function graphqlPlugin (app, opts) {
-  app.decorate('graphqlSupergraph', {
-    getter () {
-      return this[graphqlSupergraphSymbol]
-    },
-    setter (v) {
-      this[graphqlSupergraphSymbol] = v
-    }
-  })
-  app.decorate('graphqlComposerOptions', {
-    getter () {
-      return opts
-    }
-  })
-
-  app.graphqlSupergraph = createSupergraph()
-}
-
-export const graphql = fp(graphqlPlugin)

package/lib/metrics.js

@@ -1,12 +0,0 @@
-export function initMetrics (prometheus) {
-  if (!prometheus?.registry || !prometheus?.client) return null
-  const { client, registry } = prometheus
-
-  return {
-    activeWsConnections: new client.Gauge({
-      name: 'active_ws_composer_connections',
-      help: 'Active Websocket composer connections in "@platformatic/composer"',
-      registers: [registry]
-    })
-  }
-}

package/lib/not-host-constraints.js

@@ -1,31 +0,0 @@
-export const notHostConstraints = {
-  name: 'notHost',
-  storage () {
-    const store = []
-
-    return {
-      get (host) {
-        if (typeof host === 'string') {
-          for (const [hosts, value] of store) {
-            if (!hosts.includes(host)) {
-              return value
-            }
-          }
-        }
-
-        return null
-      },
-      set: (hosts, value) => {
-        store.push([hosts, value])
-      },
-      store
-    }
-  },
-  deriveConstraint (req) {
-    return req.headers.host || req.headers[':authority']
-  },
-  mustMatchWhenDerived: false,
-  validate () {
-    return true
-  }
-}