@platformatic/gateway 3.0.0-alpha.6

package/lib/graphql-fetch.js

@@ -0,0 +1,83 @@
+import { compose } from '@platformatic/graphql-composer'
+
+const placeholderSdl = 'Query { _info: String }'
+const placeholderResolvers = { Query: { _info: '@platformatic/gateway' } }
+
+// TODO support subscriptions
+// const defaultSubscriptionsOptions = {
+//   onError: function onGatewaySubscriptionsError (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 toGatewayOptions (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 application 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 applicationToSubgraphConfig (application) {
+  if (!application.graphql) {
+    return
+  }
+  return {
+    name: application.graphql.name || application.id || application.origin,
+    entities: application.graphql.entities,
+    server: {
+      host: application.graphql.host || application.origin,
+      composeEndpoint: application.graphql.composeEndpoint,
+      graphqlEndpoint: application.graphql.graphqlEndpoint
+    }
+  }
+}
+
+export async function fetchGraphqlSubgraphs (applications, options, app) {
+  const subgraphs = applications.map(applicationToSubgraphConfig).filter(s => !!s)
+  const gateway = await compose({ ...toGatewayOptions(options, app), subgraphs })
+
+  return createSupergraph({
+    logger: app.log,
+    sdl: gateway.toSdl(),
+    resolvers: gateway.resolvers
+  })
+}

package/lib/graphql-generator.js

@@ -0,0 +1,33 @@
+import fp from 'fastify-plugin'
+import mercurius from 'mercurius'
+import { fetchGraphqlSubgraphs } from './graphql-fetch.js'
+
+async function graphqlGeneratorPlugin (app, opts) {
+  if (!opts.applications.some(s => s.graphql)) {
+    return
+  }
+
+  const applications = []
+
+  for (const application of opts.applications) {
+    if (!application.graphql) {
+      continue
+    }
+    applications.push(application)
+  }
+
+  const graphqlConfig = {
+    graphiql: opts.graphql?.graphiql
+  }
+  if (applications.length > 0) {
+    const graphqlSupergraph = await fetchGraphqlSubgraphs(applications, 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

@@ -0,0 +1,29 @@
+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('graphqlGatewayOptions', {
+    getter () {
+      return opts
+    }
+  })
+  app.decorate('graphqlComposerOptions', {
+    getter () {
+      return opts
+    }
+  })
+
+  app.graphqlSupergraph = createSupergraph()
+}
+
+export const graphql = fp(graphqlPlugin)

package/lib/metrics.js

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

package/lib/not-host-constraints.js

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

package/lib/openapi-composer.js

@@ -0,0 +1,101 @@
+import rfdc from 'rfdc'
+import { PathAlreadyExistsError } from './errors.js'
+
+const clone = rfdc()
+
+function generateOperationIdApiPrefix (operationId) {
+  return (
+    operationId
+      .trim()
+      .replace(/[^A-Z0-9]+/gi, '_')
+      .replace(/^_+|_+$/g, '') + '_'
+  )
+}
+
+function namespaceSchemaRefs (apiPrefix, schema) {
+  if (schema.$ref && schema.$ref.startsWith('#/components/schemas')) {
+    schema.$ref = schema.$ref.replace('#/components/schemas/', '#/components/schemas/' + apiPrefix)
+  }
+  for (const childSchema of Object.values(schema)) {
+    if (typeof childSchema === 'object') {
+      namespaceSchemaRefs(apiPrefix, childSchema)
+    }
+  }
+}
+
+function namespaceSchemaOperationIds (apiPrefix, schema) {
+  if (schema.operationId) {
+    schema.operationId = apiPrefix + schema.operationId
+  }
+  for (const childSchema of Object.values(schema)) {
+    if (typeof childSchema === 'object') {
+      namespaceSchemaOperationIds(apiPrefix, childSchema)
+    }
+  }
+}
+
+export function composeOpenApi (apis, options = {}) {
+  const mergedPaths = {}
+  const mergedSchemas = {}
+  const mergedSecuritySchemes = {}
+
+  for (const { id, prefix, schema } of apis) {
+    const { paths, components } = clone(schema)
+
+    const apiPrefix = generateOperationIdApiPrefix(id)
+    for (const [path, pathSchema] of Object.entries(paths)) {
+      namespaceSchemaRefs(apiPrefix, pathSchema)
+      namespaceSchemaOperationIds(apiPrefix, pathSchema)
+
+      for (const methodSchema of Object.values(pathSchema)) {
+        if (methodSchema.security) {
+          methodSchema.security = methodSchema.security.map(security => {
+            const newSecurity = {}
+            for (const [securityKey, securityValue] of Object.entries(security)) {
+              newSecurity[apiPrefix + securityKey] = securityValue
+            }
+            return newSecurity
+          })
+        }
+      }
+
+      const mergedPath = prefix ? prefix + path : path
+
+      if (mergedPaths[mergedPath]) {
+        throw new PathAlreadyExistsError(mergedPath)
+      }
+      mergedPaths[mergedPath] = pathSchema
+    }
+
+    if (components) {
+      if (components.schemas) {
+        for (const [schemaKey, schema] of Object.entries(components.schemas)) {
+          if (schema.title == null) {
+            schema.title = schemaKey
+          }
+          namespaceSchemaRefs(apiPrefix, schema)
+          mergedSchemas[apiPrefix + schemaKey] = schema
+        }
+      }
+
+      if (components.securitySchemes) {
+        for (const [securitySchemeKey, securityScheme] of Object.entries(components.securitySchemes)) {
+          mergedSecuritySchemes[apiPrefix + securitySchemeKey] = securityScheme
+        }
+      }
+    }
+  }
+
+  return {
+    openapi: '3.0.0',
+    info: {
+      title: options.title || 'Platformatic Gateway',
+      version: options.version || '1.0.0'
+    },
+    components: {
+      securitySchemes: mergedSecuritySchemes,
+      schemas: mergedSchemas
+    },
+    paths: mergedPaths
+  }
+}

package/lib/openapi-config-schema.js

@@ -0,0 +1,89 @@
+const ignoreSchema = {
+  type: 'object',
+  properties: {
+    ignore: { type: 'boolean' }
+  },
+  additionalProperties: false
+}
+
+const aliasSchema = {
+  type: 'object',
+  properties: {
+    alias: { type: 'string' }
+  }
+}
+
+const jsonSchemaSchema = {
+  $id: 'json-schema',
+  type: 'object',
+  properties: {
+    type: { type: 'string' },
+    properties: {
+      type: 'object',
+      additionalProperties: {
+        oneOf: [
+          { $ref: 'json-schema' },
+          {
+            type: 'object',
+            properties: {
+              rename: { type: 'string' }
+            },
+            additionalProperties: false
+          }
+        ]
+      }
+    },
+    items: { $ref: 'json-schema' }
+  },
+  additionalProperties: false
+}
+
+const routeSchema = {
+  anyOf: [
+    ignoreSchema,
+    {
+      type: 'object',
+      properties: {
+        responses: {
+          type: 'object',
+          properties: {
+            200: { $ref: 'json-schema' }
+          }
+        }
+      }
+    }
+  ]
+}
+
+export const openApiConfigSchema = {
+  type: 'object',
+  properties: {
+    paths: {
+      type: 'object',
+      additionalProperties: {
+        anyOf: [
+          ignoreSchema,
+          aliasSchema,
+          {
+            type: 'object',
+            properties: {
+              get: routeSchema,
+              post: routeSchema,
+              put: routeSchema,
+              patch: routeSchema,
+              delete: routeSchema,
+              options: routeSchema,
+              head: routeSchema,
+              trace: routeSchema
+            },
+            additionalProperties: false
+          }
+        ]
+      }
+    }
+  },
+  additionalProperties: false,
+  definitions: {
+    'json-schema': jsonSchemaSchema
+  }
+}

package/lib/openapi-generator.js

@@ -0,0 +1,215 @@
+import fastifyReplyFrom from '@fastify/reply-from'
+import fastifySwagger from '@fastify/swagger'
+import fp from 'fastify-plugin'
+import { readFile } from 'node:fs/promises'
+import { getGlobalDispatcher, request } from 'undici'
+import { CouldNotReadOpenAPIConfigError } from './errors.js'
+import { composeOpenApi } from './openapi-composer.js'
+import { loadOpenApiConfig } from './openapi-load-config.js'
+import { modifyOpenApiSchema, originPathSymbol } from './openapi-modifier.js'
+import { openApiScalar } from './openapi-scalar.js'
+import { prefixWithSlash } from './utils.js'
+
+async function fetchOpenApiSchema (openApiUrl) {
+  const { body } = await request(openApiUrl)
+  return body.json()
+}
+
+async function readOpenApiSchema (pathToSchema) {
+  const schemaFile = await readFile(pathToSchema, 'utf-8')
+  return JSON.parse(schemaFile)
+}
+
+async function getOpenApiSchema (origin, openapi) {
+  if (openapi.url) {
+    const openApiUrl = origin + prefixWithSlash(openapi.url)
+    return fetchOpenApiSchema(openApiUrl)
+  }
+
+  return readOpenApiSchema(openapi.file)
+}
+
+function createPathMapper (originOpenApiPath, renamedOpenApiPath, prefix) {
+  if (prefix + originOpenApiPath === renamedOpenApiPath) {
+    return path => path.slice(prefix.length)
+  }
+
+  const extractParamsRegexp = generateRouteRegex(renamedOpenApiPath)
+  return path => {
+    const routeParams = path.match(extractParamsRegexp).slice(1)
+    return generateRenamedPath(originOpenApiPath, routeParams)
+  }
+}
+
+function generateRouteRegex (route) {
+  const regex = route.replace(/{(.*?)}/g, '(.*)')
+  return new RegExp(regex)
+}
+
+function generateRenamedPath (renamedOpenApiPath, routeParams) {
+  return renamedOpenApiPath.replace(/{(.*?)}/g, () => routeParams.shift())
+}
+
+async function openApiGatewayPlugin (app, { opts, generated }) {
+  const { apiByApiRoutes } = generated
+
+  const dispatcher = getGlobalDispatcher()
+
+  await app.register(fastifyReplyFrom, {
+    undici: dispatcher,
+    destroyAgent: false
+  })
+
+  await app.register(await import('@platformatic/fastify-openapi-glue'), {
+    specification: app.composedOpenApiSchema,
+    addEmptySchema: opts.addEmptySchema,
+    operationResolver: (operationId, method, openApiPath) => {
+      const { origin, prefix, schema } = apiByApiRoutes[openApiPath]
+      const originPath = schema[originPathSymbol]
+
+      const mapRoutePath = createPathMapper(originPath, openApiPath, prefix)
+
+      return {
+        config: { openApiPath },
+        handler: (req, reply) => {
+          const routePath = req.raw.url.split('?')[0]
+          const newRoutePath = mapRoutePath(routePath)
+
+          const replyOptions = {}
+          const onResponse = (request, reply, res) => {
+            app.openTelemetry?.endHTTPSpanClient(reply.request.proxedCallSpan, {
+              statusCode: reply.statusCode,
+              headers: res.headers
+            })
+
+            const onResponse = req.routeOptions.config?.onGatewayResponse ?? req.routeOptions.config?.onComposerResponse
+            if (onResponse) {
+              onResponse(request, reply, res.stream)
+            } else {
+              reply.send(res.stream)
+            }
+          }
+          const 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
+            }
+
+            return headers
+          }
+          replyOptions.onResponse = onResponse
+          replyOptions.rewriteRequestHeaders = rewriteRequestHeaders
+
+          reply.from(origin + newRoutePath, replyOptions)
+        }
+      }
+    }
+  })
+
+  app.addHook('preValidation', async req => {
+    if (typeof req.query.fields === 'string') {
+      req.query.fields = req.query.fields.split(',')
+    }
+  })
+}
+
+export async function openApiGenerator (app, opts) {
+  if (!opts.applications.some(s => s.openapi)) {
+    return
+  }
+
+  const { applications } = opts
+
+  const openApiSchemas = []
+  const apiByApiRoutes = {}
+
+  for (const { id, origin, openapi } of applications) {
+    if (!openapi) continue
+
+    let openapiConfig = null
+    if (openapi.config) {
+      try {
+        openapiConfig = await loadOpenApiConfig(openapi.config)
+      } catch (error) {
+        app.log.error(error)
+        throw new CouldNotReadOpenAPIConfigError(id)
+      }
+    }
+
+    let originSchema = null
+    try {
+      originSchema = await getOpenApiSchema(origin, openapi)
+    } catch (error) {
+      app.log.error(error, `failed to fetch schema for "${id} application"`)
+      continue
+    }
+
+    const schema = modifyOpenApiSchema(app, originSchema, openapiConfig)
+
+    const prefix = openapi.prefix ? prefixWithSlash(openapi.prefix) : ''
+    for (const path in schema.paths) {
+      apiByApiRoutes[prefix + path] = {
+        origin,
+        prefix,
+        schema: schema.paths[path]
+      }
+    }
+
+    openApiSchemas.push({ id, prefix, schema, originSchema, config: openapiConfig })
+  }
+
+  const composedOpenApiSchema = composeOpenApi(openApiSchemas, opts.openapi)
+
+  app.decorate('openApiSchemas', openApiSchemas)
+  app.decorate('composedOpenApiSchema', composedOpenApiSchema)
+
+  await app.register(fastifySwagger, {
+    exposeRoute: true,
+    openapi: {
+      info: {
+        title: opts.openapi?.title || 'Platformatic Gateway',
+        version: opts.openapi?.version || '1.0.0'
+      },
+      servers: [{ url: globalThis.platformatic?.runtimeBasePath ?? '/' }],
+      components: app.composedOpenApiSchema.components
+    },
+    transform ({ schema, url }) {
+      for (const application of opts.applications) {
+        if (!application.proxy) continue
+
+        const prefix = application.proxy.prefix ?? ''
+        const proxyPrefix = prefix.at(-1) === '/' ? prefix.slice(0, -1) : prefix
+
+        const proxyUrls = [proxyPrefix + '/', proxyPrefix + '/*']
+        if (proxyUrls.includes(url)) {
+          schema = schema ?? {}
+          schema.hide = true
+          break
+        }
+      }
+      return { schema, url }
+    }
+  })
+
+  await app.register(openApiScalar, opts)
+
+  return { apiByApiRoutes }
+}
+
+export const openApiGateway = fp(openApiGatewayPlugin)

package/lib/openapi-load-config.js

@@ -0,0 +1,31 @@
+import Ajv from 'ajv'
+import { readFile } from 'node:fs/promises'
+import { ValidationErrors } from './errors.js'
+import { openApiConfigSchema } from './openapi-config-schema.js'
+
+const ajv = new Ajv()
+const ajvValidate = ajv.compile(openApiConfigSchema)
+
+export async function loadOpenApiConfig (pathToConfig) {
+  const openApiConfigFile = await readFile(pathToConfig, 'utf-8')
+  const openApiConfig = JSON.parse(openApiConfigFile)
+
+  if (!ajvValidate(openApiConfig)) {
+    const validationErrors = ajvValidate.errors.map(err => {
+      return {
+        /* c8 ignore next 1 */
+        path: err.instancePath === '' ? '/' : err.instancePath,
+        message: err.message + ' ' + JSON.stringify(err.params)
+      }
+    })
+    throw new ValidationErrors(
+      validationErrors
+        .map(err => {
+          return err.message
+        })
+        .join('\n')
+    )
+  }
+
+  return openApiConfig
+}