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

package/lib/openapi-composer.js

@@ -1,101 +0,0 @@
-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 Composer',
-      version: options.version || '1.0.0'
-    },
-    components: {
-      securitySchemes: mergedSecuritySchemes,
-      schemas: mergedSchemas
-    },
-    paths: mergedPaths
-  }
-}

package/lib/openapi-config-schema.js

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

@@ -1,213 +0,0 @@
-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 openApiComposerPlugin (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
-            })
-            if (req.routeOptions.config?.onComposerResponse) {
-              req.routeOptions.config?.onComposerResponse(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 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(',')
-    }
-  })
-}
-
-export async function openApiGenerator (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 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 })
-  }
-
-  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 }
-    }
-  })
-
-  await app.register(openApiScalar, opts)
-
-  return { apiByApiRoutes }
-}
-
-export const openApiComposer = fp(openApiComposerPlugin)

package/lib/openapi-load-config.js

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

package/lib/openapi-modifier.js

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

package/lib/openapi-scalar.js

@@ -1,22 +0,0 @@
-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)