@platformatic/gateway 3.0.0-alpha.6

package/lib/openapi-modifier.js

@@ -0,0 +1,131 @@
+import traverse from 'json-schema-traverse'
+import rfdc from 'rfdc'
+
+const clone = rfdc()
+
+const MODIFICATION_KEYWORDS = ['rename']
+
+export const originPathSymbol = Symbol('originPath')
+
+function findDataBySchemaPointer (schemaPointer, schema, data, parentData, callback) {
+  const schemaPointerParts = schemaPointer.split('/').slice(1)
+
+  for (const schemaPointerPart of schemaPointerParts) {
+    parentData = data
+    schema = schema[schemaPointerPart]
+
+    if (schemaPointerPart === 'properties') continue
+
+    if (schemaPointerPart === 'items') {
+      for (const item of data) {
+        const newSchemaPointer = '/' + schemaPointerParts.slice(1).join('/')
+        findDataBySchemaPointer(newSchemaPointer, schema, item, parentData, callback)
+      }
+      return
+    }
+
+    data = data[schemaPointerPart]
+  }
+
+  callback(data, parentData)
+}
+
+function getModificationRules (modificationSchema) {
+  const modificationRules = {}
+
+  function getModificationRules (schema, jsonPointer) {
+    const schemaKeys = Object.keys(schema)
+    const modificationKeys = schemaKeys.filter(key => MODIFICATION_KEYWORDS.includes(key))
+
+    if (modificationKeys.length === 0) return
+    modificationRules[jsonPointer] = schema
+  }
+
+  traverse(modificationSchema, { cb: getModificationRules })
+  return modificationRules
+}
+
+function modifySchema (originSchema, modificationRules) {
+  function modifyOriginSchema (schema, jsonPointer, rs, psp, pk, parentSchema, keyIndex) {
+    const modificationRule = modificationRules[jsonPointer]
+    if (!modificationRule) return
+
+    if (modificationRule.rename) {
+      parentSchema.properties[modificationRule.rename] = schema
+      delete parentSchema.properties[keyIndex]
+
+      if (parentSchema.required) {
+        const index = parentSchema.required.indexOf(keyIndex)
+        if (index !== -1) {
+          parentSchema.required[index] = modificationRule.rename
+        }
+      }
+    }
+  }
+  traverse(originSchema, { cb: modifyOriginSchema })
+}
+
+function modifyPayload (payload, originSchema, modificationRules) {
+  for (const schemaJsonPointer in modificationRules) {
+    const rule = modificationRules[schemaJsonPointer]
+
+    findDataBySchemaPointer(schemaJsonPointer, originSchema, payload, null, (data, parentData) => {
+      if (rule.rename) {
+        parentData[rule.rename] = data
+        delete parentData[schemaJsonPointer.split('/').pop()]
+      }
+    })
+  }
+}
+
+export function modifyOpenApiSchema (app, schema, config) {
+  const newSchemaPaths = {}
+  const { paths } = clone(schema)
+
+  for (let path in paths) {
+    const pathConfig = config?.paths?.[path]
+    const pathSchema = paths[path]
+
+    if (pathConfig?.ignore) continue
+
+    pathSchema[originPathSymbol] = path
+
+    if (pathConfig?.alias) {
+      path = pathConfig.alias
+    }
+
+    for (const method in pathSchema) {
+      const routeConfig = pathConfig?.[method.toLowerCase()]
+
+      if (routeConfig?.ignore) {
+        delete pathSchema[method]
+        continue
+      }
+
+      const modificationResponseSchema = routeConfig?.responses?.['200']
+      if (!modificationResponseSchema) continue
+
+      const modificationRules = getModificationRules(modificationResponseSchema)
+
+      function onRouteHook (routeOptions) {
+        const routeSchema = routeOptions.schema
+        const responseSchema = routeSchema.response?.['200']
+        modifySchema(responseSchema, modificationRules)
+
+        async function onGatewayResponse (request, reply, body) {
+          const payload = await body.json()
+          modifyPayload(payload, responseSchema, modificationRules)
+          reply.send(payload)
+        }
+        routeOptions.config.onGatewayResponse = onGatewayResponse
+      }
+
+      app.platformatic.addGatewayOnRouteHook(path, [method], onRouteHook)
+      app.platformatic.addComposerOnRouteHook(path, [method], onRouteHook)
+    }
+    if (Object.keys(pathSchema).length === 0) continue
+    newSchemaPaths[path] = pathSchema
+  }
+
+  return { ...schema, paths: newSchemaPaths }
+}

package/lib/openapi-scalar.js

@@ -0,0 +1,22 @@
+import fp from 'fastify-plugin'
+
+async function openApiScalarPlugin (app, opts) {
+  const { default: scalarTheme } = await import('@platformatic/scalar-theme')
+  const { default: scalarApiReference } = await import('@scalar/fastify-api-reference')
+
+  /** Serve spec file in yaml and json */
+  app.get('/documentation/json', { schema: { hide: true } }, async () => app.swagger())
+  app.get('/documentation/yaml', { schema: { hide: true } }, async () => app.swagger({ yaml: true }))
+
+  const routePrefix = opts.openapi?.swaggerPrefix || '/documentation'
+
+  await app.register(scalarApiReference, {
+    logLevel: 'warn',
+    routePrefix,
+    configuration: {
+      customCss: scalarTheme.theme
+    }
+  })
+}
+
+export const openApiScalar = fp(openApiScalarPlugin)

package/lib/proxy.js

@@ -0,0 +1,266 @@
+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.gateway.proxy.route')
+
+const urlPattern = /^https?:\/\//
+
+async function resolveApplicationProxyParameters (application) {
+  // Get meta information from the application, if any, to eventually hook up to a TCP port
+  const allMeta = (await globalThis[kITC]?.send('getApplicationMeta', application.id)) ?? {}
+  const meta = allMeta.gateway ?? allMeta.composer ?? { prefix: application.id }
+
+  // If no prefix could be found, assume the application id
+  let prefix = (application.proxy?.prefix ?? meta.prefix ?? application.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 application meta
+    if (basePath && !application.proxy?.prefix && prefix.startsWith(basePath)) {
+      prefix = prefix.substring(basePath.length)
+    }
+
+    // The rewritePrefix purposely ignores application.proxy?.prefix to let
+    // the application always being able to configure their value
+    rewritePrefix = meta.prefix ?? application.id
+    internalRewriteLocationHeader = false
+  }
+
+  if (application.proxy?.ws?.hooks) {
+    const hooks = await loadModule(createRequire(import.meta.filename), application.proxy.ws.hooks.path)
+    application.proxy.ws.hooks = hooks
+  }
+
+  return {
+    origin: application.origin,
+    url: meta.url,
+    prefix,
+    rewritePrefix,
+    internalRewriteLocationHeader,
+    needsRootTrailingSlash: meta.needsRootTrailingSlash,
+    needsRefererBasedRedirect: meta.needsRefererBasedRedirect,
+    upstream: application.proxy?.upstream,
+    ws: application.proxy?.ws
+  }
+}
+
+let metrics
+
+async function proxyPlugin (app, opts) {
+  const meta = { proxies: {} }
+  const hostnameLessProxies = []
+
+  for (const application of opts.applications) {
+    if (!application.proxy) {
+      // When a application defines no expose config at all
+      // we assume a proxy exposed with a prefix equals to its id or meta.prefix
+      if (application.proxy === false || application.openapi || application.graphql) {
+        continue
+      }
+    }
+
+    const parameters = await resolveApplicationProxyParameters(application)
+    const {
+      prefix,
+      origin,
+      url,
+      rewritePrefix,
+      internalRewriteLocationHeader,
+      needsRootTrailingSlash,
+      needsRefererBasedRedirect,
+      ws
+    } = parameters
+    meta.proxies[application.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 application, 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 applications in Swagger
+    if (!application.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: application.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 application
+          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 application')
+          return reply.send(error)
+        }
+      }
+    }
+
+    hostnameLessProxies.push(proxyOptions)
+
+    const host = application.proxy?.hostname
+
+    if (host) {
+      await app.register(httpProxy, {
+        ...proxyOptions,
+        prefix: '/',
+        constraints: { host }
+      })
+    }
+  }
+
+  const hostnames = opts.applications.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.capability?.registerMeta(meta)
+}
+
+export const proxy = fp(proxyPlugin)

package/lib/root.js

@@ -0,0 +1,75 @@
+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.gateway.applications.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' }
+    }
+  })
+}