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

package/lib/proxy.js

@@ -1,265 +0,0 @@
-import httpProxy from '@fastify/http-proxy'
-import { ensureLoggableError, loadModule } from '@platformatic/foundation'
-import fp from 'fastify-plugin'
-import { createRequire } from 'node:module'
-import { workerData } from 'node:worker_threads'
-import { getGlobalDispatcher } from 'undici'
-import { initMetrics } from './metrics.js'
-
-const kITC = Symbol.for('plt.runtime.itc')
-const kProxyRoute = Symbol('plt.composer.proxy.route')
-
-const urlPattern = /^https?:\/\//
-
-async function resolveServiceProxyParameters (service) {
-  // Get meta information from the service, if any, to eventually hook up to a TCP port
-  const meta = (await globalThis[kITC]?.send('getServiceMeta', service.id))?.composer ?? { prefix: service.id }
-
-  // If no prefix could be found, assume the service id
-  let prefix = (service.proxy?.prefix ?? meta.prefix ?? service.id).replace(/(\/$)/g, '')
-  let rewritePrefix = ''
-  let internalRewriteLocationHeader = true
-
-  if (meta.wantsAbsoluteUrls) {
-    const basePath = workerData.config.basePath
-
-    // Strip the runtime basepath from the prefix when it comes from the service meta
-    if (basePath && !service.proxy?.prefix && prefix.startsWith(basePath)) {
-      prefix = prefix.substring(basePath.length)
-    }
-
-    // The rewritePrefix purposely ignores service.proxy?.prefix to let
-    // the service always being able to configure their value
-    rewritePrefix = meta.prefix ?? service.id
-    internalRewriteLocationHeader = false
-  }
-
-  if (service.proxy?.ws?.hooks) {
-    const hooks = await loadModule(createRequire(import.meta.filename), service.proxy.ws.hooks.path)
-    service.proxy.ws.hooks = hooks
-  }
-
-  return {
-    origin: service.origin,
-    url: meta.url,
-    prefix,
-    rewritePrefix,
-    internalRewriteLocationHeader,
-    needsRootTrailingSlash: meta.needsRootTrailingSlash,
-    needsRefererBasedRedirect: meta.needsRefererBasedRedirect,
-    upstream: service.proxy?.upstream,
-    ws: service.proxy?.ws
-  }
-}
-
-let metrics
-
-async function proxyPlugin (app, opts) {
-  const meta = { proxies: {} }
-  const hostnameLessProxies = []
-
-  for (const service of opts.services) {
-    if (!service.proxy) {
-      // When a service defines no expose config at all
-      // we assume a proxy exposed with a prefix equals to its id or meta.prefix
-      if (service.proxy === false || service.openapi || service.graphql) {
-        continue
-      }
-    }
-
-    const parameters = await resolveServiceProxyParameters(service)
-    const {
-      prefix,
-      origin,
-      url,
-      rewritePrefix,
-      internalRewriteLocationHeader,
-      needsRootTrailingSlash,
-      needsRefererBasedRedirect,
-      ws
-    } = parameters
-    meta.proxies[service.id] = parameters
-
-    const basePath = `/${prefix ?? ''}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
-    const dispatcher = getGlobalDispatcher()
-
-    let preRewrite = null
-
-    if (needsRootTrailingSlash) {
-      preRewrite = function preRewrite (url) {
-        if (url === basePath) {
-          url += '/'
-        }
-
-        return url
-      }
-    }
-
-    /*
-      Some frontends, like Astro (https://github.com/withastro/astro/issues/11445)
-      generate invalid paths in development mode which ignore the basePath.
-      In that case we try to properly redirect the browser by trying to understand the prefix
-      from the Referer header.
-    */
-    if (needsRefererBasedRedirect) {
-      app.addHook('preHandler', function refererBasedRedirectPreHandler (req, reply, done) {
-        // If the URL is already targeted to the service, do nothing
-        if (req.url.startsWith(basePath)) {
-          done()
-          return
-        }
-
-        // Use the referer to understand the desired intent
-        const referer = req.headers.referer
-
-        if (!referer) {
-          done()
-          return
-        }
-
-        const path = new URL(referer).pathname
-
-        // If we have a match redirect
-        if (path.startsWith(basePath)) {
-          reply.redirect(`${basePath}${req.url}`, 308)
-        }
-
-        done()
-      })
-    }
-
-    // Do not show proxied services in Swagger
-    if (!service.openapi) {
-      app.addHook('onRoute', routeOptions => {
-        if (routeOptions.config?.[kProxyRoute] && routeOptions.url.startsWith(basePath)) {
-          routeOptions.schema ??= {}
-          routeOptions.schema.hide = true
-        }
-      })
-    }
-
-    const toReplace = url
-      ? new RegExp(
-        url
-          .replace(/127\.0\.0\.1/, 'localhost')
-          .replace(/\[::\]/, 'localhost')
-          .replace('http://', 'https?://')
-      )
-      : null
-
-    if (!metrics) {
-      metrics = initMetrics(globalThis.platformatic?.prometheus)
-    }
-
-    const proxyOptions = {
-      prefix,
-      rewritePrefix,
-      upstream: service.proxy?.upstream ?? origin,
-      preRewrite,
-
-      websocket: true,
-      wsUpstream: ws?.upstream ?? url ?? origin,
-      wsReconnect: ws?.reconnect,
-      wsHooks: {
-        onConnect: (...args) => {
-          metrics?.activeWsConnections?.inc()
-          ws?.hooks?.onConnect(...args)
-        },
-        onDisconnect: (...args) => {
-          metrics?.activeWsConnections?.dec()
-          ws?.hooks?.onDisconnect(...args)
-        },
-        onReconnect: ws?.hooks?.onReconnect,
-        onPong: ws?.hooks?.onPong,
-        onIncomingMessage: ws?.hooks?.onIncomingMessage,
-        onOutgoingMessage: ws?.hooks?.onOutgoingMessage
-      },
-
-      undici: dispatcher,
-      destroyAgent: false,
-      config: {
-        [kProxyRoute]: true
-      },
-
-      internalRewriteLocationHeader: false,
-      replyOptions: {
-        rewriteHeaders: headers => {
-          let location = headers.location
-          if (location) {
-            if (toReplace) {
-              location = location.replace(toReplace, '')
-            }
-            if (!urlPattern.test(location) && internalRewriteLocationHeader) {
-              location = location.replace(rewritePrefix, prefix)
-            }
-            headers.location = location
-          }
-          return headers
-        },
-        rewriteRequestHeaders: (request, headers) => {
-          const targetUrl = `${origin}${request.url}`
-          const context = request.span?.context
-          const { span, telemetryHeaders } = app.openTelemetry?.startHTTPSpanClient(
-            targetUrl,
-            request.method,
-            context
-          ) || { span: null, telemetryHeaders: {} }
-          // We need to store the span in a different object
-          // to correctly close it in the onResponse hook
-          // Note that we have 2 spans:
-          // - request.span: the span of the request to the proxy
-          // - request.proxedCallSpan: the span of the request to the proxied service
-          request.proxedCallSpan = span
-
-          headers = {
-            ...headers,
-            ...telemetryHeaders,
-            'x-forwarded-for': request.ip,
-            'x-forwarded-host': request.host,
-            'x-forwarded-proto': request.protocol
-          }
-
-          request.log.trace({ headers }, 'rewritten headers before proxying')
-
-          return headers
-        },
-        onResponse: (_, reply, res) => {
-          app.openTelemetry?.endHTTPSpanClient(reply.request.proxedCallSpan, {
-            statusCode: reply.statusCode,
-            headers: res.headers
-          })
-          reply.send(res.stream)
-        },
-        onError: (reply, { error }) => {
-          app.log.error({ error: ensureLoggableError(error) }, 'Error while proxying request to another service')
-          return reply.send(error)
-        }
-      }
-    }
-
-    hostnameLessProxies.push(proxyOptions)
-
-    const host = service.proxy?.hostname
-
-    if (host) {
-      await app.register(httpProxy, {
-        ...proxyOptions,
-        prefix: '/',
-        constraints: { host }
-      })
-    }
-  }
-
-  const hostnames = opts.services.map(s => s.proxy?.hostname).filter(Boolean)
-  for (const options of hostnameLessProxies) {
-    if (hostnames.length > 0) {
-      options.constraints = { notHost: hostnames }
-    }
-
-    await app.register(httpProxy, options)
-  }
-
-  opts.stackable?.registerMeta(meta)
-}
-
-export const proxy = fp(proxyPlugin)

package/lib/root.js

@@ -1,75 +0,0 @@
-import fastifyStatic from '@fastify/static'
-import fastifyView from '@fastify/view'
-import userAgentParser from 'my-ua-parser'
-import { join } from 'node:path'
-import nunjucks from 'nunjucks'
-
-export default function root (app) {
-  app.register(fastifyStatic, {
-    root: join(import.meta.dirname, '../public')
-  })
-  app.register(fastifyView, {
-    engine: {
-      nunjucks
-    },
-    root: join(import.meta.dirname, '../public')
-  })
-  // root endpoint
-  app.route({
-    method: 'GET',
-    path: '/',
-    schema: { hide: true },
-    handler: async (req, reply) => {
-      const uaString = req.headers['user-agent']
-      let hasOpenAPIServices = false
-      let hasGraphQLServices = false
-      if (uaString) {
-        const parsed = userAgentParser(uaString)
-        if (parsed.browser.name !== undefined) {
-          const serviceTypes = {
-            proxy: {
-              title: 'Reverse Proxy',
-              icon: './images/reverse-proxy.svg',
-              services: []
-            },
-            openapi: {
-              title: 'OpenAPI',
-              icon: './images/openapi.svg',
-              services: []
-            },
-            graphql: {
-              title: 'GraphQL',
-              icon: './images/graphql.svg',
-              services: []
-            }
-          }
-
-          app.platformatic.config.composer.services.forEach(s => {
-            if (s.openapi) {
-              hasOpenAPIServices = true
-              serviceTypes.openapi.services.push(s)
-            }
-            if (s.graphql) {
-              hasGraphQLServices = true
-              serviceTypes.graphql.services.push(s)
-            }
-            if (s.proxy) {
-              serviceTypes.proxy.services.push({
-                ...s,
-                externalLink: `${s.proxy.prefix}/`
-              })
-            }
-          })
-
-          return reply.view('index.njk', {
-            hasGraphQLServices,
-            hasOpenAPIServices,
-            services: serviceTypes
-          })
-        }
-      }
-      // Load services
-      return { message: 'Welcome to Platformatic! Please visit https://docs.platformatic.dev' }
-    }
-  })
-}

package/lib/schema.js

@@ -1,258 +0,0 @@
-#! /usr/bin/env node
-
-import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
-import {
-  fastifyServer as server,
-  schemaComponents as utilsSchemaComponents,
-  watch,
-  wrappedRuntime
-} from '@platformatic/foundation'
-import { schemaComponents as serviceSchemaComponents } from '@platformatic/service'
-import { readFileSync } from 'node:fs'
-import { resolve } from 'node:path'
-
-const { $defs, graphqlBase, openApiBase, plugins } = serviceSchemaComponents
-
-export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
-export const version = packageJson.version
-
-export const openApiService = {
-  type: 'object',
-  properties: {
-    url: { type: 'string' },
-    file: { type: 'string', resolvePath: true },
-    prefix: { type: 'string' },
-    config: { type: 'string', resolvePath: true }
-  },
-  anyOf: [{ required: ['url'] }, { required: ['file'] }],
-  additionalProperties: false
-}
-
-export const entityResolver = {
-  type: 'object',
-  properties: {
-    name: { type: 'string' },
-    argsAdapter: {
-      anyOf: [{ typeof: 'function' }, { type: 'string' }]
-    },
-    partialResults: {
-      anyOf: [{ typeof: 'function' }, { type: 'string' }]
-    }
-  },
-  required: ['name'],
-  additionalProperties: false
-}
-
-export const entities = {
-  type: 'object',
-  patternProperties: {
-    '^.*$': {
-      type: 'object',
-      properties: {
-        pkey: { type: 'string' },
-        resolver: entityResolver,
-        fkeys: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              type: { type: 'string' },
-              field: { type: 'string' },
-              as: { type: 'string' },
-              pkey: { type: 'string' },
-              subgraph: { type: 'string' },
-              resolver: entityResolver
-            },
-            required: ['type']
-          }
-        },
-        many: {
-          type: 'array',
-          items: {
-            type: 'object',
-            properties: {
-              type: { type: 'string' },
-              fkey: { type: 'string' },
-              as: { type: 'string' },
-              pkey: { type: 'string' },
-              subgraph: { type: 'string' },
-              resolver: entityResolver
-            },
-            required: ['type', 'fkey', 'resolver']
-          }
-        }
-      }
-    }
-  }
-}
-
-export const graphqlService = {
-  anyOf: [
-    { type: 'boolean' },
-    {
-      type: 'object',
-      properties: {
-        host: { type: 'string' },
-        name: { type: 'string' },
-        graphqlEndpoint: { type: 'string', default: '/graphql' },
-        composeEndpoint: { type: 'string', default: '/.well-known/graphql-composition' },
-        entities
-      },
-      additionalProperties: false
-    }
-  ]
-}
-
-export const graphqlComposerOptions = {
-  type: 'object',
-  properties: {
-    ...graphqlBase.properties,
-    // TODO support subscriptions, subscriptions: { type: 'boolean', default: false },
-    onSubgraphError: { typeof: 'function' },
-    defaultArgsAdapter: {
-      oneOf: [{ typeof: 'function' }, { type: 'string' }]
-    },
-    entities,
-    addEntitiesResolvers: { type: 'boolean', default: false }
-  },
-  additionalProperties: false
-}
-
-export const composer = {
-  type: 'object',
-  properties: {
-    services: {
-      type: 'array',
-      items: {
-        type: 'object',
-        properties: {
-          id: { type: 'string' },
-          origin: { type: 'string' },
-          openapi: openApiService,
-          graphql: graphqlService,
-          proxy: {
-            anyOf: [
-              { type: 'boolean', const: false },
-              {
-                type: 'object',
-                properties: {
-                  upstream: { type: 'string' },
-                  prefix: { type: 'string' },
-                  hostname: { type: 'string' },
-                  ws: {
-                    type: 'object',
-                    properties: {
-                      upstream: { type: 'string' },
-                      reconnect: {
-                        type: 'object',
-                        properties: {
-                          pingInterval: { type: 'number' },
-                          maxReconnectionRetries: { type: 'number' },
-                          reconnectInterval: { type: 'number' },
-                          reconnectDecay: { type: 'number' },
-                          connectionTimeout: { type: 'number' },
-                          reconnectOnClose: { type: 'boolean' },
-                          logs: { type: 'boolean' }
-                        }
-                      },
-                      hooks: {
-                        type: 'object',
-                        properties: {
-                          path: { type: 'string' }
-                        },
-                        required: ['path'],
-                        additionalProperties: false
-                      }
-                    },
-                    required: [],
-                    additionalProperties: false
-                  }
-                },
-                required: [],
-                additionalProperties: false
-              }
-            ]
-          }
-        },
-        required: ['id'],
-        additionalProperties: false
-      }
-    },
-    openapi: openApiBase,
-    graphql: graphqlComposerOptions,
-    addEmptySchema: { type: 'boolean', default: false },
-    refreshTimeout: { type: 'integer', minimum: 0, default: 1000 }
-  },
-  required: [],
-  default: {},
-  additionalProperties: false
-}
-
-export const types = {
-  type: 'object',
-  properties: {
-    autogenerate: {
-      type: 'boolean'
-    },
-    dir: {
-      description: 'The path to the directory the types should be generated in.',
-      type: 'string',
-      default: 'types',
-      resolvePath: true
-    }
-  },
-  additionalProperties: false
-}
-
-export const schemaComponents = {
-  openApiService,
-  entityResolver,
-  entities,
-  graphqlService,
-  graphqlComposerOptions,
-  composer,
-  types
-}
-
-export const schema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/composer/${packageJson.version}.json`,
-  $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic Composer Config',
-  type: 'object',
-  properties: {
-    basePath: {
-      type: 'string'
-    },
-    server,
-    composer,
-    types,
-    plugins,
-    application: basicSchemaComponents.application,
-    runtime: wrappedRuntime,
-    telemetry: utilsSchemaComponents.telemetry,
-    watch: {
-      anyOf: [
-        watch,
-        {
-          type: 'boolean'
-        },
-        {
-          type: 'string'
-        }
-      ]
-    },
-    $schema: {
-      type: 'string'
-    },
-    module: {
-      type: 'string'
-    }
-  },
-  additionalProperties: false,
-  $defs
-}
-
-/* c8 ignore next 3 */
-if (process.argv[1] === import.meta.filename) {
-  console.log(JSON.stringify(schema, null, 2))
-}

package/lib/stackable.js

@@ -1,88 +0,0 @@
-import { kMetadata, replaceEnv } from '@platformatic/foundation'
-import { ServiceStackable } from '@platformatic/service'
-import { ensureServices, platformaticComposer } from './application.js'
-import { notHostConstraints } from './not-host-constraints.js'
-import { packageJson } from './schema.js'
-
-const kITC = Symbol.for('plt.runtime.itc')
-
-export class ComposerStackable extends ServiceStackable {
-  #meta
-  #dependencies
-
-  constructor (root, config, context) {
-    super(root, config, context)
-    this.type = 'composer'
-    this.version = packageJson.version
-
-    this.applicationFactory = this.context.applicationFactory ?? platformaticComposer
-    this.fastifyOptions ??= {}
-    this.fastifyOptions.constraints = { notHost: notHostConstraints }
-  }
-
-  async getBootstrapDependencies () {
-    await ensureServices(this.serviceId, this.config)
-
-    const composedServices = this.config.composer?.services
-    const dependencies = []
-
-    if (Array.isArray(composedServices)) {
-      dependencies.push(
-        ...(await Promise.all(
-          composedServices.map(async service => {
-            return this.#parseDependency(service.id, service.origin)
-          })
-        ))
-      )
-    }
-
-    this.#dependencies = dependencies
-    return this.#dependencies
-  }
-
-  registerMeta (meta) {
-    this.#meta = Object.assign(this.#meta ?? {}, meta)
-  }
-
-  async getMeta () {
-    const serviceMeta = super.getMeta()
-    const composerMeta = this.#meta ? { composer: this.#meta } : undefined
-
-    return {
-      ...serviceMeta,
-      ...composerMeta
-    }
-  }
-
-  async isHealthy () {
-    // If no dependencies (still booting), assume healthy
-    if (this.#dependencies) {
-      const composedServices = this.#dependencies.map(dep => dep.id)
-      const workers = await globalThis[kITC].send('getWorkers')
-
-      for (const worker of Object.values(workers)) {
-        if (composedServices.includes(worker.service) && !worker.status.startsWith('start')) {
-          globalThis[kITC].notify('event', { event: 'unhealthy' })
-          return false
-        }
-      }
-    }
-
-    globalThis[kITC].notify('event', { event: 'healthy' })
-    return true
-  }
-
-  async #parseDependency (id, urlString) {
-    let url = `http://${id}.plt.local`
-
-    if (urlString) {
-      const remoteUrl = await replaceEnv(urlString, this.config[kMetadata].env)
-
-      if (remoteUrl) {
-        url = remoteUrl
-      }
-    }
-
-    return { id, url, local: url.endsWith('.plt.local') }
-  }
-}

package/lib/upgrade.js

@@ -1,20 +0,0 @@
-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: resolve(import.meta.dirname, 'versions'),
-    input: config,
-    logger: logger?.child({ name: '@platformatic/composer' }) ?? abstractLogger
-  })
-
-  let result
-
-  for await (const updated of iterator) {
-    result = updated.result
-  }
-
-  return result
-}