@platformatic/composer 2.72.0 → 3.0.0-alpha.1

package/lib/openapi-generator.js

@@ -1,16 +1,14 @@
-'use strict'
-
-const { readFile } = require('node:fs/promises')
-const { request, getGlobalDispatcher } = require('undici')
-const fp = require('fastify-plugin')
-const fastifySwagger = require('@fastify/swagger')
-
-const errors = require('./errors')
-const { modifyOpenApiSchema, originPathSymbol } = require('./openapi-modifier')
-const composeOpenApi = require('./openapi-composer')
-const loadOpenApiConfig = require('./openapi-load-config.js')
-const { prefixWithSlash } = require('./utils.js')
-const openApiScalar = require('./openapi-scalar')
+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)
@@ -31,95 +29,35 @@ async function getOpenApiSchema (origin, openapi) {
   return readOpenApiSchema(openapi.file)
 }
 
-async function generateComposedOpenApi (app, opts) {
-  if (!opts.services.some(s => s.openapi)) { return }
-
-  const { services } = opts
-
-  const openApiSchemas = []
-  const apiByApiRoutes = {}
-
-  for (const { id, origin, openapi } of services) {
-    if (!openapi) continue
-
-    let openapiConfig = null
-    if (openapi.config) {
-      try {
-        openapiConfig = await loadOpenApiConfig(openapi.config)
-      } catch (error) {
-        app.log.error(error)
-        throw new errors.CouldNotReadOpenAPIConfigError(id)
-      }
-    }
-
-    let originSchema = null
-    try {
-      originSchema = await getOpenApiSchema(origin, openapi)
-    } catch (error) {
-      app.log.error(error, `failed to fetch schema for "${id} service"`)
-      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 })
+function createPathMapper (originOpenApiPath, renamedOpenApiPath, prefix) {
+  if (prefix + originOpenApiPath === renamedOpenApiPath) {
+    return path => path.slice(prefix.length)
   }
 
-  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 Composer',
-        version: opts.openapi?.version || '1.0.0'
-      },
-      servers: [{ url: globalThis.platformatic?.runtimeBasePath ?? '/' }],
-      components: app.composedOpenApiSchema.components
-    },
-    transform ({ schema, url }) {
-      for (const service of opts.services) {
-        if (!service.proxy) continue
-
-        const prefix = service.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 }
-    }
-  })
+  const extractParamsRegexp = generateRouteRegex(renamedOpenApiPath)
+  return path => {
+    const routeParams = path.match(extractParamsRegexp).slice(1)
+    return generateRenamedPath(originOpenApiPath, routeParams)
+  }
+}
 
-  await app.register(openApiScalar, opts)
+function generateRouteRegex (route) {
+  const regex = route.replace(/{(.*?)}/g, '(.*)')
+  return new RegExp(regex)
+}
 
-  return { apiByApiRoutes }
+function generateRenamedPath (renamedOpenApiPath, routeParams) {
+  return renamedOpenApiPath.replace(/{(.*?)}/g, () => routeParams.shift())
 }
 
-async function openApiComposer (app, { opts, generated }) {
+async function openApiComposerPlugin (app, { opts, generated }) {
   const { apiByApiRoutes } = generated
 
   const dispatcher = getGlobalDispatcher()
 
-  await app.register(require('@fastify/reply-from'), {
+  await app.register(fastifyReplyFrom, {
     undici: dispatcher,
-    destroyAgent: false,
+    destroyAgent: false
   })
 
   await app.register(await import('@platformatic/fastify-openapi-glue'), {
@@ -152,7 +90,11 @@ async function openApiComposer (app, { opts, generated }) {
           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: {} }
+            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:
@@ -164,7 +106,7 @@ async function openApiComposer (app, { opts, generated }) {
               ...headers,
               ...telemetryHeaders,
               'x-forwarded-for': request.ip,
-              'x-forwarded-host': request.host,
+              'x-forwarded-host': request.host
             }
 
             return headers
@@ -173,38 +115,99 @@ async function openApiComposer (app, { opts, generated }) {
           replyOptions.rewriteRequestHeaders = rewriteRequestHeaders
 
           reply.from(origin + newRoutePath, replyOptions)
-        },
+        }
       }
-    },
+    }
   })
 
-  app.addHook('preValidation', async (req) => {
+  app.addHook('preValidation', async req => {
     if (typeof req.query.fields === 'string') {
       req.query.fields = req.query.fields.split(',')
     }
   })
 }
 
-function createPathMapper (originOpenApiPath, renamedOpenApiPath, prefix) {
-  if (prefix + originOpenApiPath === renamedOpenApiPath) {
-    return (path) => path.slice(prefix.length)
+export async function openApiGenerator (app, opts) {
+  if (!opts.services.some(s => s.openapi)) {
+    return
   }
 
-  const extractParamsRegexp = generateRouteRegex(renamedOpenApiPath)
-  return (path) => {
-    const routeParams = path.match(extractParamsRegexp).slice(1)
-    return generateRenamedPath(originOpenApiPath, routeParams)
+  const { services } = opts
+
+  const openApiSchemas = []
+  const apiByApiRoutes = {}
+
+  for (const { id, origin, openapi } of services) {
+    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} service"`)
+      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 })
   }
-}
 
-function generateRouteRegex (route) {
-  const regex = route.replace(/{(.*?)}/g, '(.*)')
-  return new RegExp(regex)
-}
+  const composedOpenApiSchema = composeOpenApi(openApiSchemas, opts.openapi)
 
-function generateRenamedPath (renamedOpenApiPath, routeParams) {
-  return renamedOpenApiPath.replace(/{(.*?)}/g, () => routeParams.shift())
+  app.decorate('openApiSchemas', openApiSchemas)
+  app.decorate('composedOpenApiSchema', composedOpenApiSchema)
+
+  await app.register(fastifySwagger, {
+    exposeRoute: true,
+    openapi: {
+      info: {
+        title: opts.openapi?.title || 'Platformatic Composer',
+        version: opts.openapi?.version || '1.0.0'
+      },
+      servers: [{ url: globalThis.platformatic?.runtimeBasePath ?? '/' }],
+      components: app.composedOpenApiSchema.components
+    },
+    transform ({ schema, url }) {
+      for (const service of opts.services) {
+        if (!service.proxy) continue
+
+        const prefix = service.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 }
 }
 
-module.exports.openApiGenerator = generateComposedOpenApi
-module.exports.openApiComposer = fp(openApiComposer)
+export const openApiComposer = fp(openApiComposerPlugin)

package/lib/openapi-load-config.js

@@ -1,31 +1,31 @@
-'use strict'
-
-const { readFile } = require('node:fs/promises')
-const Ajv = require('ajv')
-const openApiConfigSchema = require('./openapi-config-schema')
-const errors = require('./errors')
+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)
 
-async function loadOpenApiConfig (pathToConfig) {
+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) => {
+    const validationErrors = ajvValidate.errors.map(err => {
       return {
         /* c8 ignore next 1 */
         path: err.instancePath === '' ? '/' : err.instancePath,
-        message: err.message + ' ' + JSON.stringify(err.params),
+        message: err.message + ' ' + JSON.stringify(err.params)
       }
     })
-    throw new errors.ValidationErrors(validationErrors.map((err) => {
-      return err.message
-    }).join('\n'))
+    throw new ValidationErrors(
+      validationErrors
+        .map(err => {
+          return err.message
+        })
+        .join('\n')
+    )
   }
 
   return openApiConfig
 }
-
-module.exports = loadOpenApiConfig

package/lib/openapi-modifier.js

@@ -1,11 +1,12 @@
-'use strict'
+import traverse from 'json-schema-traverse'
+import rfdc from 'rfdc'
 
-const traverse = require('json-schema-traverse')
-const clone = require('rfdc')()
+const clone = rfdc()
 
-const originPathSymbol = Symbol('originPath')
 const MODIFICATION_KEYWORDS = ['rename']
 
+export const originPathSymbol = Symbol('originPath')
+
 function findDataBySchemaPointer (schemaPointer, schema, data, parentData, callback) {
   const schemaPointerParts = schemaPointer.split('/').slice(1)
 
@@ -34,9 +35,7 @@ function getModificationRules (modificationSchema) {
 
   function getModificationRules (schema, jsonPointer) {
     const schemaKeys = Object.keys(schema)
-    const modificationKeys = schemaKeys.filter(
-      key => MODIFICATION_KEYWORDS.includes(key)
-    )
+    const modificationKeys = schemaKeys.filter(key => MODIFICATION_KEYWORDS.includes(key))
 
     if (modificationKeys.length === 0) return
     modificationRules[jsonPointer] = schema
@@ -70,22 +69,16 @@ 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()]
-        }
+    findDataBySchemaPointer(schemaJsonPointer, originSchema, payload, null, (data, parentData) => {
+      if (rule.rename) {
+        parentData[rule.rename] = data
+        delete parentData[schemaJsonPointer.split('/').pop()]
       }
-    )
+    })
   }
 }
 
-function modifyOpenApiSchema (app, schema, config) {
+export function modifyOpenApiSchema (app, schema, config) {
   const newSchemaPaths = {}
   const { paths } = clone(schema)
 
@@ -133,5 +126,3 @@ function modifyOpenApiSchema (app, schema, config) {
 
   return { ...schema, paths: newSchemaPaths }
 }
-
-module.exports = { modifyOpenApiSchema, originPathSymbol }

package/lib/openapi-scalar.js

@@ -1,8 +1,6 @@
-'use strict'
+import fp from 'fastify-plugin'
 
-const fp = require('fastify-plugin')
-
-async function openApiScalar (app, opts) {
+async function openApiScalarPlugin (app, opts) {
   const { default: scalarTheme } = await import('@platformatic/scalar-theme')
   const { default: scalarApiReference } = await import('@scalar/fastify-api-reference')
 
@@ -21,4 +19,4 @@ async function openApiScalar (app, opts) {
   })
 }
 
-module.exports = fp(openApiScalar)
+export const openApiScalar = fp(openApiScalarPlugin)

package/lib/proxy.js

@@ -1,11 +1,9 @@
-'use strict'
-
-const httpProxy = require('@fastify/http-proxy')
-const { ensureLoggableError } = require('@platformatic/utils')
-const fp = require('fastify-plugin')
-const { workerData } = require('node:worker_threads')
-const { getGlobalDispatcher } = require('undici')
-const { initMetrics } = require('./metrics')
+import httpProxy from '@fastify/http-proxy'
+import { ensureLoggableError, loadModule } from '@platformatic/utils'
+import fp from 'fastify-plugin'
+import { createRequire } from 'node:module'
+import { workerData } from 'node:worker_threads'
+import { getGlobalDispatcher } from 'undici'
 
 const kITC = Symbol.for('plt.runtime.itc')
 const kProxyRoute = Symbol('plt.composer.proxy.route')
@@ -36,7 +34,7 @@ async function resolveServiceProxyParameters (service) {
   }
 
   if (service.proxy?.ws?.hooks) {
-    const hooks = require(service.proxy.ws.hooks.path)
+    const hooks = await loadModule(createRequire(import.meta.filename), service.proxy.ws.hooks.path)
     service.proxy.ws.hooks = hooks
   }
 
@@ -53,9 +51,7 @@ async function resolveServiceProxyParameters (service) {
   }
 }
 
-let metrics
-
-module.exports = fp(async function (app, opts) {
+async function proxyPlugin (app, opts) {
   const meta = { proxies: {} }
   const hostnameLessProxies = []
 
@@ -84,16 +80,16 @@ module.exports = fp(async function (app, opts) {
     const basePath = `/${prefix ?? ''}`.replaceAll(/\/+/g, '/').replace(/\/$/, '')
     const dispatcher = getGlobalDispatcher()
 
-    let preRewrite = null
-
     if (needsRootTrailingSlash) {
-      preRewrite = function preRewrite (url) {
-        if (url === basePath) {
-          url += '/'
+      app.addHook('preHandler', function rootTrailingSlashPreHandler (req, reply, done) {
+        if (req.url !== basePath) {
+          done()
+          return
         }
 
-        return url
-      }
+        const { url, options } = reply.fromParameters(req.url + '/', req.params, prefix)
+        reply.from(url.replace(/\/+$/, '/'), options)
+      })
     }
 
     /*
@@ -148,28 +144,17 @@ module.exports = fp(async function (app, opts) {
       )
       : 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)
-        },
+        onConnect: ws?.hooks?.onConnect,
+        onDisconnect: ws?.hooks?.onDisconnect,
         onReconnect: ws?.hooks?.onReconnect,
         onPong: ws?.hooks?.onPong,
         onIncomingMessage: ws?.hooks?.onIncomingMessage,
@@ -260,5 +245,7 @@ module.exports = fp(async function (app, opts) {
     await app.register(httpProxy, options)
   }
 
-  opts.context?.stackable?.registerMeta(meta)
-})
+  opts.stackable?.registerMeta(meta)
+}
+
+export const proxy = fp(proxyPlugin)

package/lib/{root-endpoint/index.js → root.js}

@@ -1,18 +1,18 @@
-'use strict'
+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'
 
-const { join } = require('node:path')
-const fastifyStatic = require('@fastify/static')
-const userAgentParser = require('my-ua-parser')
-
-module.exports = async (app, opts) => {
+export default function root (app) {
   app.register(fastifyStatic, {
-    root: join(__dirname, 'public'),
+    root: join(import.meta.dirname, '../public')
   })
-  app.register(require('@fastify/view'), {
+  app.register(fastifyView, {
     engine: {
-      nunjucks: require('nunjucks')
+      nunjucks
     },
-    root: join(__dirname, 'public')
+    root: join(import.meta.dirname, '../public')
   })
   // root endpoint
   app.route({
@@ -44,7 +44,7 @@ module.exports = async (app, opts) => {
             }
           }
 
-          app.platformatic.config.composer.services.forEach((s) => {
+          app.platformatic.config.composer.services.forEach(s => {
             if (s.openapi) {
               hasOpenAPIServices = true
               serviceTypes.openapi.services.push(s)
@@ -70,6 +70,6 @@ module.exports = async (app, opts) => {
       }
       // Load services
       return { message: 'Welcome to Platformatic! Please visit https://docs.platformatic.dev' }
-    },
+    }
   })
 }