@platformatic/composer 2.74.3 → 3.0.0-alpha.2

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,10 @@
-'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/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.composer.proxy.route')
@@ -36,7 +35,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
   }
 
@@ -55,7 +54,7 @@ async function resolveServiceProxyParameters (service) {
 
 let metrics
 
-module.exports = fp(async function (app, opts) {
+async function proxyPlugin (app, opts) {
   const meta = { proxies: {} }
   const hostnameLessProxies = []
 
@@ -260,5 +259,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' }
-    },
+    }
   })
 }

package/lib/schema.js

@@ -1,13 +1,22 @@
 #! /usr/bin/env node
-'use strict'
 
-const { metrics, server, plugins, watch, clients, openApiBase, openApiDefs, graphqlBase } =
-  require('@platformatic/service').schemas
-const { schemaComponents } = require('@platformatic/utils')
-const telemetry = require('@platformatic/telemetry').schema
-const pkg = require('../package.json')
+import { schemaComponents as basicSchemaComponents } from '@platformatic/basic'
+import {
+  fastifyServer as server,
+  schemaComponents as utilsSchemaComponents,
+  watch,
+  wrappedRuntime
+} from '@platformatic/foundation'
+import { schemaComponents as serviceSchemaComponents } from '@platformatic/service'
+import { readFileSync } from 'node:fs'
+import { resolve } from 'node:path'
 
-const openApiService = {
+const { $defs, graphqlBase, openApiBase, plugins } = serviceSchemaComponents
+
+export const packageJson = JSON.parse(readFileSync(resolve(import.meta.dirname, '../package.json'), 'utf8'))
+export const version = packageJson.version
+
+export const openApiService = {
   type: 'object',
   properties: {
     url: { type: 'string' },
@@ -19,7 +28,7 @@ const openApiService = {
   additionalProperties: false
 }
 
-const entityResolver = {
+export const entityResolver = {
   type: 'object',
   properties: {
     name: { type: 'string' },
@@ -34,7 +43,7 @@ const entityResolver = {
   additionalProperties: false
 }
 
-const entities = {
+export const entities = {
   type: 'object',
   patternProperties: {
     '^.*$': {
@@ -77,7 +86,7 @@ const entities = {
   }
 }
 
-const graphqlService = {
+export const graphqlService = {
   anyOf: [
     { type: 'boolean' },
     {
@@ -94,7 +103,7 @@ const graphqlService = {
   ]
 }
 
-const graphqlComposerOptions = {
+export const graphqlComposerOptions = {
   type: 'object',
   properties: {
     ...graphqlBase.properties,
@@ -109,7 +118,7 @@ const graphqlComposerOptions = {
   additionalProperties: false
 }
 
-const composer = {
+export const composer = {
   type: 'object',
   properties: {
     services: {
@@ -179,7 +188,7 @@ const composer = {
   additionalProperties: false
 }
 
-const types = {
+export const types = {
   type: 'object',
   properties: {
     autogenerate: {
@@ -195,10 +204,20 @@ const types = {
   additionalProperties: false
 }
 
-const platformaticComposerSchema = {
-  $id: `https://schemas.platformatic.dev/@platformatic/composer/${pkg.version}.json`,
+export const schemaComponents = {
+  openApiService,
+  entityResolver,
+  entities,
+  graphqlService,
+  graphqlComposerOptions,
+  composer,
+  types
+}
+
+export const schema = {
+  $id: `https://schemas.platformatic.dev/@platformatic/composer/${packageJson.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
-  title: 'Platformatic Composer',
+  title: 'Platformatic Composer Config',
   type: 'object',
   properties: {
     basePath: {
@@ -206,12 +225,11 @@ const platformaticComposerSchema = {
     },
     server,
     composer,
-    metrics,
     types,
     plugins,
-    clients,
-    runtime: schemaComponents.wrappedRuntime,
-    telemetry,
+    application: basicSchemaComponents.application,
+    runtime: wrappedRuntime,
+    telemetry: utilsSchemaComponents.telemetry,
     watch: {
       anyOf: [
         watch,
@@ -231,12 +249,10 @@ const platformaticComposerSchema = {
     }
   },
   additionalProperties: false,
-  $defs: openApiDefs
+  $defs
 }
 
-module.exports.schema = platformaticComposerSchema
-
 /* c8 ignore next 3 */
-if (require.main === module) {
-  console.log(JSON.stringify(platformaticComposerSchema, null, 2))
+if (process.argv[1] === import.meta.filename) {
+  console.log(JSON.stringify(schema, null, 2))
 }