@platformatic/composer 3.4.1 → 3.5.1

package/lib/openapi-composer.js

@@ -1,81 +0,0 @@
-'use strict'
-
-const clone = require('rfdc')()
-const errors = require('./errors')
-
-function composeOpenApi (apis, options = {}) {
-  const mergedPaths = {}
-  const mergedSchemas = {}
-
-  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)
-
-      const mergedPath = prefix ? prefix + path : path
-
-      if (mergedPaths[mergedPath]) {
-        throw new errors.PathAlreadyExistsError(mergedPath)
-      }
-      mergedPaths[mergedPath] = pathSchema
-    }
-
-    if (components && 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
-      }
-    }
-  }
-
-  return {
-    openapi: '3.0.0',
-    info: {
-      title: options.title || 'Platformatic Composer',
-      version: options.version || '1.0.0',
-    },
-    components: {
-      schemas: mergedSchemas,
-    },
-    paths: mergedPaths,
-  }
-}
-
-function generateOperationIdApiPrefix (operationId) {
-  return operationId.trim()
-    .replace(/[^A-Z0-9]+/ig, '_')
-    .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)
-    }
-  }
-}
-
-module.exports = composeOpenApi

package/lib/openapi-config-schema.js

@@ -1,93 +0,0 @@
-'use strict'
-
-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' },
-          },
-        },
-      },
-    },
-  ],
-}
-
-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,
-  },
-}
-
-module.exports = openApiConfigSchema

package/lib/openapi-fetch-schemas.mjs

@@ -1,61 +0,0 @@
-import { writeFile } from 'node:fs/promises'
-
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { request } from 'undici'
-
-import { loadConfig } from '@platformatic/config'
-import { platformaticComposer } from '../index.js'
-import errors from '../lib/errors.js'
-import { prefixWithSlash } from './utils.js'
-
-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 errors.FailedToFetchOpenAPISchemaError(openApiUrl)
-  }
-  const schema = await body.json()
-
-  if (openapi.file !== undefined) {
-    await writeFile(openapi.file, JSON.stringify(schema, null, 2))
-  }
-
-  return schema
-}
-
-export default async function fetchOpenApiSchemas (_args) {
-  const logger = pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid',
-  }))
-
-  const { configManager } = await loadConfig({}, _args, platformaticComposer)
-  await configManager.parseAndValidate()
-  const config = configManager.current
-  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)
-  fetchOpenApiResults.forEach((result, index) => {
-    const serviceId = servicesWithValidOpenApi[index].id
-    if (result.status === 'rejected') {
-      logger.error(`Failed to fetch OpenAPI schema for service with id ${serviceId}: ${result.reason}`)
-    } else {
-      logger.info(`Successfully fetched OpenAPI schema for service with id ${serviceId}`)
-    }
-  })
-}
-
-export {
-  fetchOpenApiSchema,
-  fetchOpenApiSchemas,
-}

package/lib/openapi-generator.js

@@ -1,167 +0,0 @@
-'use strict'
-
-const { readFile } = require('node:fs/promises')
-const { request, getGlobalDispatcher } = require('undici')
-const fp = require('fastify-plugin')
-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')
-
-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)
-}
-
-async function composeOpenAPI (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 })
-  }
-
-  app.decorate('openApiSchemas', openApiSchemas)
-
-  const composedOpenApiSchema = composeOpenApi(openApiSchemas, opts.openapi)
-
-  const dispatcher = getGlobalDispatcher()
-
-  await app.register(require('@fastify/reply-from'), {
-    undici: dispatcher,
-    destroyAgent: false,
-  })
-
-  await app.register(await import('fastify-openapi-glue'), {
-    specification: 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, { stream }) => {
-            app.openTelemetry?.endHTTPSpanClient(reply.request.proxedCallSpan, { statusCode: reply.statusCode })
-            if (req.routeOptions.config?.onComposerResponse) {
-              req.routeOptions.config?.onComposerResponse(request, reply, stream)
-            } else {
-              reply.send(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 service
-            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(',')
-    }
-  })
-}
-
-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())
-}
-
-module.exports = fp(composeOpenAPI)

package/lib/openapi-load-config.js

@@ -1,31 +0,0 @@
-'use strict'
-
-const { readFile } = require('node:fs/promises')
-const Ajv = require('ajv')
-const openApiConfigSchema = require('./openapi-config-schema')
-const errors = require('./errors')
-
-const ajv = new Ajv()
-const ajvValidate = ajv.compile(openApiConfigSchema)
-
-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 errors.ValidationErrors(validationErrors.map((err) => {
-      return err.message
-    }).join('\n'))
-  }
-
-  return openApiConfig
-}
-
-module.exports = loadOpenApiConfig

package/lib/openapi-modifier.js

@@ -1,137 +0,0 @@
-'use strict'
-
-const traverse = require('json-schema-traverse')
-const clone = require('rfdc')()
-
-const originPathSymbol = Symbol('originPath')
-const MODIFICATION_KEYWORDS = ['rename']
-
-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()]
-        }
-      }
-    )
-  }
-}
-
-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)
-
-      app.platformatic.addComposerOnRouteHook(path, [method], routeOptions => {
-        const routeSchema = routeOptions.schema
-        const responseSchema = routeSchema.response?.['200']
-        modifySchema(responseSchema, modificationRules)
-
-        async function onComposerResponse (request, reply, body) {
-          const payload = await body.json()
-          modifyPayload(payload, responseSchema, modificationRules)
-          reply.send(payload)
-        }
-        routeOptions.config.onComposerResponse = onComposerResponse
-      })
-    }
-    if (Object.keys(pathSchema).length === 0) continue
-    newSchemaPaths[path] = pathSchema
-  }
-
-  return { ...schema, paths: newSchemaPaths }
-}
-
-module.exports = { modifyOpenApiSchema, originPathSymbol }

package/lib/openapi.js

@@ -1,49 +0,0 @@
-'use strict'
-
-const fp = require('fastify-plugin')
-
-async function composeOpenAPI (app, opts) {
-  await app.register(require('@fastify/swagger'), {
-    exposeRoute: true,
-    openapi: {
-      info: {
-        title: opts.openapi?.title || 'Platformatic Composer',
-        version: opts.openapi?.version || '1.0.0'
-      }
-    },
-    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 { default: scalarTheme } = await import('@platformatic/scalar-theme')
-
-  /** 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(require('@scalar/fastify-api-reference'), {
-    logLevel: 'warn',
-    routePrefix,
-    configuration: {
-      customCss: scalarTheme.theme
-    }
-  })
-}
-
-module.exports = fp(composeOpenAPI)