@platformatic/runtime 1.43.0 → 1.45.0

package/lib/config.js

@@ -103,135 +103,87 @@ function missingDependencyErrorMessage (clientName, service, configManager) {
 }
 
 async function parseClientsAndComposer (configManager) {
-  for (let i = 0; i < configManager.current.services.length; ++i) {
-    const service = configManager.current.services[i]
+  for (const service of configManager.current.services) {
     const cm = new ConfigManager({ source: service.config })
     const configString = await cm.load()
-    const parsed = cm._parser(configString)
-
-    if (Array.isArray(parsed.composer?.services)) {
-      for (let i = 0; i < parsed.composer.services.length; ++i) {
-        const dep = parsed.composer.services[i]
-        /* c8 ignore next 4 - why c8? */
-        const clientName = dep.id ?? ''
-        const dependency = configManager.current.serviceMap.get(clientName)
-
-        let isLocal = true
-        let clientUrl = null
-
-        if (dep.origin !== undefined) {
-          try {
-            clientUrl = await cm.replaceEnv(dep.origin)
-            isLocal = false
-            /* c8 ignore next 4 */
-          } catch (err) {
-            // The MissingValueError is an error coming from pupa: https://github.com/sindresorhus/pupa#missingvalueerror
-            // All other errors are simply rethrown.
-            if (err.name !== 'MissingValueError') {
-              throw err
-            }
+    const serviceConfig = cm._parser(configString)
 
-            if (dependency !== undefined && dep.origin === `{${err.key}}`) {
-              clientUrl = `http://${clientName}.plt.local`
-              service.localServiceEnvVars.set(err.key, clientUrl)
-            }
-          }
-        }
+    async function parseConfigUrl (urlString) {
+      if (!urlString) {
+        return { url: null, envVar: null }
+      }
 
-        if (isLocal) {
-          if (dependency === undefined) {
-            throw new errors.MissingDependencyError(missingDependencyErrorMessage(clientName, service, configManager))
-          }
-          clientUrl = `http://${clientName}.plt.local`
-          dependency.dependents.push(service.id)
+      try {
+        const url = await cm.replaceEnv(urlString)
+        return { url, envVar: null }
+      } catch (err) {
+        // The MissingValueError is an error coming from pupa
+        // https://github.com/sindresorhus/pupa#missingvalueerror
+        // All other errors are simply re-thrown.
+        if (err.name !== 'MissingValueError' || urlString !== `{${err.key}}`) {
+          throw err
         }
-
-        service.dependencies.push({
-          id: clientName,
-          url: clientUrl,
-          local: isLocal
-        })
+        return { url: null, envVar: err.key }
       }
     }
 
-    if (Array.isArray(parsed.clients)) {
-      const promises = parsed.clients.map((client) => {
-        // eslint-disable-next-line no-async-promise-executor
-        return new Promise(async (resolve, reject) => {
-          let clientName = client.serviceId || ''
-          let clientUrl
-          let missingKey
-          let isLocal = false
+    async function addServiceDependency (service, dependencyId, urlString) {
+      let { url, envVar } = await parseConfigUrl(urlString)
+      if (url !== null) {
+        service.dependencies.push({ id: dependencyId, url, local: false })
+        return
+      }
 
-          if (clientName === '' || client.url !== undefined) {
-            try {
-              clientUrl = await cm.replaceEnv(client.url)
-              /* c8 ignore next 2 - unclear why c8 is unhappy here */
-            } catch (err) {
-              if (err.name !== 'MissingValueError') {
-                /* c8 ignore next 3 */
-                reject(err)
-                return
-              }
+      const depService = configManager.current.serviceMap.get(dependencyId)
+      if (depService === undefined) {
+        throw new errors.MissingDependencyError(
+          missingDependencyErrorMessage(dependencyId, service, configManager)
+        )
+      }
 
-              missingKey = err.key
-            }
-            isLocal = missingKey && client.url === `{${missingKey}}`
-            /* c8 ignore next 3 */
-          } else {
-            /* c8 ignore next 2 */
-            isLocal = true
-          }
+      url = `http://${dependencyId}.plt.local`
+
+      if (envVar !== null) {
+        service.localServiceEnvVars.set(envVar, url)
+      }
 
-          /* c8 ignore next 20 - unclear why c8 is unhappy for nearly 20 lines here */
-          if (!clientName) {
+      depService.dependents.push(service.id)
+      service.dependencies.push({ id: dependencyId, url, local: true })
+    }
+
+    const composedServices = serviceConfig.composer?.services
+    if (Array.isArray(composedServices)) {
+      await Promise.all(
+        composedServices.map(async (composedService) =>
+          addServiceDependency(
+            service,
+            composedService.id,
+            composedService.origin
+          )
+        )
+      )
+    }
+
+    if (Array.isArray(serviceConfig.clients)) {
+      await Promise.all(
+        serviceConfig.clients.map(async (client) => {
+          let clientServiceId = client.serviceId
+          if (!clientServiceId) {
             try {
-              const clientAbsolutePath = pathResolve(service.path, client.path)
-              const clientPackageJson = join(clientAbsolutePath, 'package.json')
-              const clientMetadata = JSON.parse(await readFile(clientPackageJson, 'utf8'))
-              clientName = clientMetadata.name ?? ''
+              const clientPath = pathResolve(service.path, client.path)
+              const clientPackageJsonPath = join(clientPath, 'package.json')
+              const clientPackageJSONFile = await readFile(clientPackageJsonPath, 'utf8')
+              const clientPackageJSON = JSON.parse(clientPackageJSONFile)
+              clientServiceId = clientPackageJSON.name ?? ''
             } catch (err) {
-              if (client.url !== undefined && client.name !== undefined) {
-                // We resolve because this is a remote client
-                resolve()
-              } else {
-                reject(err)
+              if (client.url === undefined || client.name === undefined) {
+                throw err
               }
-              return
             }
           }
-
-          if (clientUrl === undefined) {
-            // Combine the service name with the client name to avoid collisions
-            // if two or more services have a client with the same name pointing
-            // to different services.
-            clientUrl = isLocal ? `http://${clientName}.plt.local` : client.url
-          }
-
-          service.dependencies.push({
-            id: clientName,
-            url: clientUrl,
-            local: isLocal
-          })
-
-          const dependency = configManager.current.serviceMap.get(clientName)
-
-          /* c8 ignore next 4 */
-          if (dependency === undefined) {
-            throw new errors.MissingDependencyError(missingDependencyErrorMessage(clientName, service, configManager))
-          }
-
-          dependency.dependents.push(service.id)
-
-          if (isLocal) {
-            service.localServiceEnvVars.set(missingKey, clientUrl)
-          }
-
-          resolve()
+          await addServiceDependency(service, clientServiceId, client.url)
         })
-      })
-
-      await Promise.all(promises)
+      )
     }
   }
 }
@@ -240,11 +192,16 @@ function topologicalSort (configManager) {
   const { services } = configManager.current
   const topo = new Topo.Sorter()
 
-  for (let i = 0; i < services.length; ++i) {
-    const service = services[i]
-    const dependencyIds = service.dependencies.map(dep => dep.id)
+  for (const service of services) {
+    const localDependencyIds = service.dependencies
+      .filter(dep => dep.local)
+      .map(dep => dep.id)
 
-    topo.add(service, { group: service.id, after: dependencyIds, manual: true })
+    topo.add(service, {
+      group: service.id,
+      after: localDependencyIds,
+      manual: true
+    })
   }
 
   configManager.current.services = topo.sort()

package/lib/management-api.js

@@ -59,6 +59,18 @@ async function managementApiPlugin (app, opts) {
     return runtime.getServiceConfig(id)
   })
 
+  app.get('/services/:id/openapi-schema', async (request) => {
+    const { id } = request.params
+    app.log.debug('get openapi-schema', { id })
+    return runtime.getServiceOpenapiSchema(id)
+  })
+
+  app.get('/services/:id/graphql-schema', async (request) => {
+    const { id } = request.params
+    app.log.debug('get graphql-schema', { id })
+    return runtime.getServiceGraphqlSchema(id)
+  })
+
   app.post('/services/:id/start', async (request) => {
     const { id } = request.params
     app.log.debug('start service', { id })

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "1.43.0",
+  "version": "1.45.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -34,8 +34,8 @@
     "typescript": "^5.4.2",
     "undici-oidc-interceptor": "^0.5.0",
     "why-is-node-running": "^2.2.2",
-    "@platformatic/sql-graphql": "1.43.0",
-    "@platformatic/sql-mapper": "1.43.0"
+    "@platformatic/sql-graphql": "1.45.0",
+    "@platformatic/sql-mapper": "1.45.0"
   },
   "dependencies": {
     "@fastify/error": "^3.4.1",
@@ -63,13 +63,13 @@
     "undici": "^6.9.0",
     "why-is-node-running": "^2.2.2",
     "ws": "^8.16.0",
-    "@platformatic/composer": "1.43.0",
-    "@platformatic/db": "1.43.0",
-    "@platformatic/config": "1.43.0",
-    "@platformatic/generators": "1.43.0",
-    "@platformatic/utils": "1.43.0",
-    "@platformatic/telemetry": "1.43.0",
-    "@platformatic/service": "1.43.0"
+    "@platformatic/composer": "1.45.0",
+    "@platformatic/config": "1.45.0",
+    "@platformatic/db": "1.45.0",
+    "@platformatic/generators": "1.45.0",
+    "@platformatic/telemetry": "1.45.0",
+    "@platformatic/service": "1.45.0",
+    "@platformatic/utils": "1.45.0"
   },
   "standard": {
     "ignore": [