@platformatic/runtime 1.53.3 → 2.0.0-alpha.10

package/lib/schema.js

@@ -2,11 +2,13 @@
 'use strict'
 
 const telemetry = require('@platformatic/telemetry').schema
-const { server } = require('@platformatic/service').schema
+const {
+  schemaComponents: { server }
+} = require('@platformatic/utils')
+
 const pkg = require('../package.json')
-const version = 'v' + pkg.version
 const platformaticRuntimeSchema = {
-  $id: `https://platformatic.dev/schemas/${version}/runtime`,
+  $id: `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`,
   $schema: 'http://json-schema.org/draft-07/schema#',
   type: 'object',
   properties: {
@@ -38,7 +40,7 @@ const platformaticRuntimeSchema = {
           additionalProperties: {
             type: 'object',
             additionalProperties: false,
-            required: ['id', 'config'],
+            required: ['id'],
             properties: {
               id: {
                 type: 'string'
@@ -59,7 +61,7 @@ const platformaticRuntimeSchema = {
     entrypoint: {
       type: 'string'
     },
-    hotReload: {
+    watch: {
       anyOf: [
         {
           type: 'boolean'
@@ -69,9 +71,6 @@ const platformaticRuntimeSchema = {
         }
       ]
     },
-    allowCycles: {
-      type: 'boolean'
-    },
     inspectorOptions: {
       type: 'object',
       properties: {
@@ -84,7 +83,7 @@ const platformaticRuntimeSchema = {
         breakFirstLine: {
           type: 'boolean'
         },
-        hotReloadDisabled: {
+        watchDisabled: {
           type: 'boolean'
         }
       }
@@ -97,34 +96,37 @@ const platformaticRuntimeSchema = {
           additionalProperties: true
         },
         interceptors: {
-          anyOf: [{
-            type: 'array',
-            items: {
-              $ref: '#/$defs/undiciInterceptor'
-            }
-          }, {
-            type: 'object',
-            properties: {
-              Client: {
-                type: 'array',
-                items: {
-                  $ref: '#/$defs/undiciInterceptor'
-                }
-              },
-              Pool: {
-                type: 'array',
-                items: {
-                  $ref: '#/$defs/undiciInterceptor'
-                }
-              },
-              Agent: {
-                type: 'array',
-                items: {
-                  $ref: '#/$defs/undiciInterceptor'
+          anyOf: [
+            {
+              type: 'array',
+              items: {
+                $ref: '#/$defs/undiciInterceptor'
+              }
+            },
+            {
+              type: 'object',
+              properties: {
+                Client: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/$defs/undiciInterceptor'
+                  }
+                },
+                Pool: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/$defs/undiciInterceptor'
+                  }
+                },
+                Agent: {
+                  type: 'array',
+                  items: {
+                    $ref: '#/$defs/undiciInterceptor'
+                  }
                 }
               }
             }
-          }]
+          ]
         }
       }
     },
@@ -155,10 +157,7 @@ const platformaticRuntimeSchema = {
           type: 'object',
           properties: {
             port: {
-              anyOf: [
-                { type: 'integer' },
-                { type: 'string' }
-              ]
+              anyOf: [{ type: 'integer' }, { type: 'string' }]
             },
             hostname: { type: 'string' },
             endpoint: { type: 'string' },
@@ -184,14 +183,17 @@ const platformaticRuntimeSchema = {
       default: true,
       anyOf: [
         { type: 'boolean' },
-        { type: 'string' }
+        {
+          type: 'number',
+          minimum: 100
+        }
       ]
     },
     services: {
       type: 'array',
       items: {
         type: 'object',
-        required: ['id', 'path', 'config'],
+        anyOf: [{ required: ['id', 'path'] }, { required: ['id', 'url'] }],
         properties: {
           id: {
             type: 'string'
@@ -203,6 +205,9 @@ const platformaticRuntimeSchema = {
           config: {
             type: 'string'
           },
+          url: {
+            type: 'string'
+          },
           useHttp: {
             type: 'boolean'
           }
@@ -210,10 +215,7 @@ const platformaticRuntimeSchema = {
       }
     }
   },
-  anyOf: [
-    { required: ['autoload', 'entrypoint'] },
-    { required: ['services', 'entrypoint'] }
-  ],
+  anyOf: [{ required: ['autoload', 'entrypoint'] }, { required: ['services', 'entrypoint'] }],
   additionalProperties: false,
   $defs: {
     undiciInterceptor: {

package/lib/start.js

@@ -1,47 +1,25 @@
 'use strict'
 
-const { once } = require('node:events')
 const inspector = require('node:inspector')
-const { join, resolve, dirname } = require('node:path')
 const { writeFile } = require('node:fs/promises')
-const { pathToFileURL } = require('node:url')
-const { Worker } = require('node:worker_threads')
-const { start: serviceStart } = require('@platformatic/service')
+const { join, resolve, dirname } = require('node:path')
+
 const { printConfigValidationErrors } = require('@platformatic/config')
+const {
+  errors: { ensureLoggableError }
+} = require('@platformatic/utils')
 const closeWithGrace = require('close-with-grace')
-const { loadConfig } = require('./load-config')
-const { startManagementApi } = require('./management-api')
-const { startPrometheusServer } = require('./prom-server.js')
-const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
-const { RuntimeApiClient, getRuntimeLogsDir } = require('./api-client.js')
-const errors = require('./errors')
-const pkg = require('../package.json')
 const pino = require('pino')
 const pretty = require('pino-pretty')
 
-const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href
-const kWorkerFile = join(__dirname, 'worker.js')
-const kWorkerExecArgv = [
-  '--no-warnings',
-  '--experimental-loader',
-  kLoaderFile
-]
-
-function startWorker ({ config, dirname, runtimeLogsDir }, env) {
-  const worker = new Worker(kWorkerFile, {
-    /* c8 ignore next */
-    execArgv: config.hotReload ? kWorkerExecArgv : [],
-    transferList: config.loggingPort ? [config.loggingPort] : [],
-    workerData: { config, dirname, runtimeLogsDir },
-    env
-  })
-
-  return worker
-}
+const pkg = require('../package.json')
+const { parseInspectorOptions, wrapConfigInRuntimeConfig } = require('./config')
+const { Runtime } = require('./runtime')
+const errors = require('./errors')
+const { getRuntimeLogsDir, loadConfig } = require('./utils')
 
 async function buildRuntime (configManager, env) {
   env = env || process.env
-  const config = configManager.current
 
   if (inspector.url()) {
     throw new errors.NodeInspectorFlagsNotSupportedError()
@@ -51,93 +29,37 @@ async function buildRuntime (configManager, env) {
     parseInspectorOptions(configManager)
   }
 
-  if (config.hotReload) {
-    config.loaderFile = kLoaderFile
-  }
-
   const dirname = configManager.dirname
   const runtimeLogsDir = getRuntimeLogsDir(dirname, process.pid)
 
-  // The configManager cannot be transferred to the worker, so remove it.
-  delete config.configManager
+  const runtime = new Runtime(configManager, runtimeLogsDir, env)
 
-  let worker = startWorker({ config, dirname, runtimeLogsDir }, env)
-
-  let managementApi = null
-
-  if (config.hotReload) {
-    /* c8 ignore next 3 */
-    process.on('SIGUSR2', () => {
-      worker.postMessage({ signal: 'SIGUSR2' })
-    })
-
-    /* c8 ignore next 3 */
-    configManager.on('update', () => {
-      // TODO(cjihrig): Need to clean up and restart the worker.
-    })
-  }
-
-  function setupExit () {
-    worker.on('exit', (code) => {
-      // runtimeApiClient.started can be false if a stop command was issued
-      // via the management API.
-      if (config.restartOnError === false || !runtimeApiClient.started) {
-        // We must stop those here in case the `closeWithGrace` callback
-        // was not called.
-        configManager.fileWatcher?.stopWatching()
-        managementApi?.close()
-        return
-      }
+  /* c8 ignore next 3 */
+  process.on('SIGUSR2', async () => {
+    runtime.logger.info('Received SIGUSR2, restarting all services ...')
 
-      worker = startWorker({ config, dirname, runtimeLogsDir }, env)
-      setupExit()
-
-      once(worker, 'message').then((msg) => {
-        runtimeApiClient.setWorker(worker).catch(() => {
-          // TODO: currently we restart if the worker fails to start intermitently
-          // should we limit this to a number of retries?
-        })
-      })
-    })
-  }
-
-  setupExit()
-
-  await once(worker, 'message') // plt:init
-
-  const runtimeApiClient = new RuntimeApiClient(
-    worker,
-    configManager,
-    runtimeLogsDir
-  )
-
-  if (config.managementApi) {
-    managementApi = await startManagementApi(runtimeApiClient, configManager)
-    runtimeApiClient.managementApi = managementApi
-    runtimeApiClient.on('start', () => {
-      runtimeApiClient.startCollectingMetrics()
-    })
-  }
-  if (config.metrics) {
-    runtimeApiClient.on('start', async () => {
-      await startPrometheusServer(runtimeApiClient, config.metrics)
-    })
-  }
+    try {
+      await runtime.restart()
+    } catch (err) {
+      runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart services.')
+    }
+  })
 
-  return runtimeApiClient
+  await runtime.init()
+  return runtime
 }
 
 async function start (args) {
   const config = await loadConfig({}, args)
 
-  if (config.configType === 'runtime') {
-    config.configManager.args = config.args
-    const app = await buildRuntime(config.configManager)
-    await app.start()
-    return app
+  if (config.configType !== 'runtime') {
+    const configManager = await wrapConfigInRuntimeConfig(config)
+    config.configManager = configManager
   }
 
-  return serviceStart(config.app, args)
+  const app = await buildRuntime(config.configManager)
+  await app.start()
+  return app
 }
 
 async function setupAndStartRuntime (config) {
@@ -156,16 +78,16 @@ async function setupAndStartRuntime (config) {
   let runtime = await buildRuntime(runtimeConfig)
 
   let address = null
-  let startErr = null
+  const startErr = null
   const originalPort = runtimeConfig.current.server?.port || 0
   while (address === null) {
     try {
       address = await runtime.start()
     } catch (err) {
-      startErr = err
       if (err.code === 'EADDRINUSE') {
         await runtime.close()
-        if (runtimeConfig.current.server.port > MAX_PORT) throw err
+
+        if (runtimeConfig.current?.server?.port > MAX_PORT) throw err
         runtimeConfig.current.server.port++
         runtime = await buildRuntime(runtimeConfig)
       } else {
@@ -174,10 +96,12 @@ async function setupAndStartRuntime (config) {
     }
   }
   if (startErr?.code === 'PLT_RUNTIME_EADDR_IN_USE') {
-    const logger = pino(pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid'
-    }))
+    const logger = pino(
+      pretty({
+        translateTime: 'SYS:HH:MM:ss',
+        ignore: 'hostname,pid'
+      })
+    )
     logger.warn(`Port: ${originalPort} is already in use!`)
     logger.warn(`Starting service on port: ${runtimeConfig.current.server.port}`)
   }
@@ -186,14 +110,22 @@ async function setupAndStartRuntime (config) {
 
 async function startCommand (args) {
   try {
-    const config = await loadConfig({}, args)
+    const config = await loadConfig(
+      {
+        alias: {
+          p: 'production'
+        },
+        boolean: ['p', 'production']
+      },
+      args
+    )
 
     const startResult = await setupAndStartRuntime(config)
 
     const runtime = startResult.runtime
     const res = startResult.address
 
-    closeWithGrace(async (event) => {
+    closeWithGrace(async event => {
       if (event.err instanceof Error) {
         console.error(event.err)
       }
@@ -204,7 +136,7 @@ async function startCommand (args) {
   } catch (err) {
     if (err.code === 'PLT_CONFIG_NO_CONFIG_FILE_FOUND' && args.length === 1) {
       const config = {
-        $schema: `https://platformatic.dev/schemas/v${pkg.version}/service`,
+        $schema: `https://schemas.platformatic.dev/@platformatic/service/${pkg.version}.json`,
         server: {
           hostname: '127.0.0.1',
           port: 3042,
@@ -230,7 +162,7 @@ async function startCommand (args) {
       console.error(`Missing config file!
   Be sure to have a config file with one of the following names:
 
-  ${err.filenames.map((s) => ' * ' + s).join('\n')}
+  ${err.filenames.map(s => ' * ' + s).join('\n')}
 
   In alternative run "npm create platformatic@latest" to generate a basic plt service config.`)
       process.exit(1)

package/lib/upgrade.js

@@ -1,6 +1,7 @@
 'use strict'
 
-const { join } = require('path')
+const { join } = require('node:path')
+
 const pkg = require('../package.json')
 
 module.exports = async function upgrade (config, version) {
@@ -10,7 +11,7 @@ module.exports = async function upgrade (config, version) {
     version,
     path: join(__dirname, 'versions'),
     input: config,
-    logger: this.logger.child({ name: '@platformatic/runtime' })
+    logger: this.logger.child({ name: '@platformatic/runtime' }),
   })
 
   let result
@@ -19,7 +20,7 @@ module.exports = async function upgrade (config, version) {
     result = updated.result
   }
 
-  result.$schema = `https://platformatic.dev/schemas/v${pkg.version}/runtime`
+  result.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`
 
   return result
 }

package/lib/utils.js

@@ -1,10 +1,58 @@
 'use strict'
+
+const { createHash } = require('node:crypto')
+const { tmpdir } = require('node:os')
+const { join } = require('node:path')
+
+const {
+  Store,
+  loadConfig: pltConfigLoadConfig,
+  loadEmptyConfig: pltConfigLoadEmptyConfig,
+} = require('@platformatic/config')
+
+const { platformaticRuntime } = require('./config')
+
 function getArrayDifference (a, b) {
   return a.filter(element => {
     return !b.includes(element)
   })
 }
 
+function getServiceUrl (id) {
+  return `http://${id}.plt.local`
+}
+
+function getRuntimeTmpDir (runtimeDir) {
+  const platformaticTmpDir = join(tmpdir(), 'platformatic', 'applications')
+  const runtimeDirHash = createHash('md5').update(runtimeDir).digest('hex')
+  return join(platformaticTmpDir, runtimeDirHash)
+}
+
+function getRuntimeLogsDir (runtimeDir, runtimePID) {
+  const runtimeTmpDir = getRuntimeTmpDir(runtimeDir)
+  return join(runtimeTmpDir, runtimePID.toString(), 'logs')
+}
+
+async function loadConfig (minimistConfig, args, overrides, replaceEnv = true) {
+  const { default: platformaticBasic } = await import('@platformatic/basic')
+  const store = new Store()
+  store.add(platformaticRuntime)
+  store.add(platformaticBasic)
+
+  return pltConfigLoadConfig(minimistConfig, args, store, overrides, replaceEnv)
+}
+
+async function loadEmptyConfig (path, overrides, replaceEnv = true) {
+  const { default: platformaticBasic } = await import('@platformatic/basic')
+
+  return pltConfigLoadEmptyConfig(path, platformaticBasic, overrides, replaceEnv)
+}
+
 module.exports = {
-  getArrayDifference
+  getArrayDifference,
+  getRuntimeLogsDir,
+  getRuntimeTmpDir,
+  getServiceUrl,
+  loadConfig,
+  loadEmptyConfig,
 }

package/lib/versions/v1.36.0.js

@@ -7,5 +7,5 @@ module.exports = {
       config.restartOnError = false
     }
     return config
-  }
+  },
 }

package/lib/versions/v1.5.0.js

@@ -7,5 +7,5 @@ module.exports = {
       delete config.watch
     }
     return config
-  }
+  },
 }

package/lib/versions/v2.0.0.js

@@ -0,0 +1,17 @@
+'use strict'
+
+module.exports = {
+  version: '1.99.0', // This is to account alpha versions as well
+  up: function (config) {
+    if (config.restartOnError === undefined) {
+      config.restartOnError = true
+    }
+
+    if (config.hotReload) {
+      config.watch = config.hotReload
+      delete config.hotReload
+    }
+
+    return config
+  },
+}