@platformatic/runtime 2.0.0-alpha.2 → 2.0.0-alpha.20

package/lib/schema.js

@@ -2,11 +2,40 @@
 'use strict'
 
 const telemetry = require('@platformatic/telemetry').schema
-const { schemas: { server } } = require('@platformatic/utils')
+const {
+  schemaComponents: { server, logger }
+} = require('@platformatic/utils')
+
+const services = {
+  type: 'array',
+  items: {
+    type: 'object',
+    anyOf: [{ required: ['id', 'path'] }, { required: ['id', 'url'] }],
+    properties: {
+      id: {
+        type: 'string'
+      },
+      path: {
+        type: 'string',
+        resolvePath: true
+      },
+      config: {
+        type: 'string'
+      },
+      url: {
+        type: 'string'
+      },
+      useHttp: {
+        type: 'boolean'
+      }
+    }
+  }
+}
+
 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: {
@@ -17,6 +46,9 @@ const platformaticRuntimeSchema = {
       type: 'string',
       resolvePath: true
     },
+    entrypoint: {
+      type: 'string'
+    },
     autoload: {
       type: 'object',
       additionalProperties: false,
@@ -38,7 +70,7 @@ const platformaticRuntimeSchema = {
           additionalProperties: {
             type: 'object',
             additionalProperties: false,
-            required: ['id', 'config'],
+            required: ['id'],
             properties: {
               id: {
                 type: 'string'
@@ -54,38 +86,20 @@ const platformaticRuntimeSchema = {
         }
       }
     },
-    telemetry,
+    services,
+    web: services,
+    logger,
     server,
-    entrypoint: {
-      type: 'string'
-    },
-    hotReload: {
+    restartOnError: {
+      default: true,
       anyOf: [
+        { type: 'boolean' },
         {
-          type: 'boolean'
-        },
-        {
-          type: 'string'
+          type: 'number',
+          minimum: 100
         }
       ]
     },
-    inspectorOptions: {
-      type: 'object',
-      properties: {
-        host: {
-          type: 'string'
-        },
-        port: {
-          type: 'number'
-        },
-        breakFirstLine: {
-          type: 'boolean'
-        },
-        hotReloadDisabled: {
-          type: 'boolean'
-        }
-      }
-    },
     undici: {
       type: 'object',
       properties: {
@@ -94,37 +108,50 @@ 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'
+                  }
                 }
               }
             }
-          }]
+          ]
         }
       }
     },
+    watch: {
+      anyOf: [
+        {
+          type: 'boolean'
+        },
+        {
+          type: 'string'
+        }
+      ]
+    },
     managementApi: {
       anyOf: [
         { type: 'boolean' },
@@ -133,11 +160,15 @@ const platformaticRuntimeSchema = {
           type: 'object',
           properties: {
             logs: {
-              maxSize: {
-                type: 'number',
-                minimum: 5,
-                default: 200
-              }
+              type: 'object',
+              properties: {
+                maxSize: {
+                  type: 'number',
+                  minimum: 5,
+                  default: 200
+                }
+              },
+              additionalProperties: false
             }
           },
           additionalProperties: false
@@ -152,10 +183,7 @@ const platformaticRuntimeSchema = {
           type: 'object',
           properties: {
             port: {
-              anyOf: [
-                { type: 'integer' },
-                { type: 'string' }
-              ]
+              anyOf: [{ type: 'integer' }, { type: 'string' }]
             },
             hostname: { type: 'string' },
             endpoint: { type: 'string' },
@@ -177,39 +205,29 @@ const platformaticRuntimeSchema = {
         }
       ]
     },
-    restartOnError: {
-      default: true,
-      anyOf: [
-        { type: 'boolean' },
-        { type: 'string' }
-      ]
-    },
-    services: {
-      type: 'array',
-      items: {
-        type: 'object',
-        required: ['id', 'path', 'config'],
-        properties: {
-          id: {
-            type: 'string'
-          },
-          path: {
-            type: 'string',
-            resolvePath: true
-          },
-          config: {
-            type: 'string'
-          },
-          useHttp: {
-            type: 'boolean'
-          }
+    telemetry,
+    inspectorOptions: {
+      type: 'object',
+      properties: {
+        host: {
+          type: 'string'
+        },
+        port: {
+          type: 'number'
+        },
+        breakFirstLine: {
+          type: 'boolean'
+        },
+        watchDisabled: {
+          type: 'boolean'
         }
       }
     }
   },
   anyOf: [
     { required: ['autoload', 'entrypoint'] },
-    { required: ['services', 'entrypoint'] }
+    { required: ['services', 'entrypoint'] },
+    { required: ['web', 'entrypoint'] }
   ],
   additionalProperties: false,
   $defs: {

package/lib/start.js

@@ -1,46 +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 { 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()
@@ -50,80 +29,30 @@ 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
-
-  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
-      }
-
-      worker = startWorker({ config, dirname, runtimeLogsDir }, env)
-      setupExit()
+  const runtime = new Runtime(configManager, runtimeLogsDir, env)
 
-      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?
-        })
-      })
-    })
-  }
+  /* c8 ignore next 3 */
+  process.on('SIGUSR2', async () => {
+    runtime.logger.info('Received SIGUSR2, restarting all services ...')
 
-  setupExit()
-
-  await once(worker, 'message') // plt:init
-
-  const runtimeApiClient = new RuntimeApiClient(
-    worker,
-    configManager,
-    runtimeLogsDir
-  )
+    try {
+      await runtime.restart()
+    } catch (err) {
+      runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart services.')
+    }
+  })
 
-  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.init()
+  } catch (e) {
+    await runtime.close()
+    throw e
   }
 
-  return runtimeApiClient
+  return runtime
 }
 
 async function start (args) {
@@ -155,15 +84,15 @@ 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
         runtimeConfig.current.server.port++
         runtime = await buildRuntime(runtimeConfig)
@@ -173,26 +102,36 @@ 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}`)
   }
   return { address, runtime }
 }
 
-async function startCommand (args) {
+async function startCommand (args, throwAllErrors = false) {
   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)
       }
@@ -201,9 +140,13 @@ async function startCommand (args) {
 
     return res
   } catch (err) {
+    if (throwAllErrors) {
+      throw 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,
@@ -229,7 +172,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,7 +1,6 @@
 'use strict'
 
-const { join } = require('path')
-const pkg = require('../package.json')
+const { join } = require('node:path')
 
 module.exports = async function upgrade (config, version) {
   const { semgrator } = await import('semgrator')
@@ -10,7 +9,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 +18,5 @@ module.exports = async function upgrade (config, version) {
     result = updated.result
   }
 
-  result.$schema = `https://platformatic.dev/schemas/v${pkg.version}/runtime`
-
   return result
 }

package/lib/utils.js

@@ -1,10 +1,74 @@
 '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)
+
+  const id = platformaticRuntime.schema.$id.replace('@platformatic/runtime', 'wattpm')
+  const schema = {
+    ...platformaticRuntime.schema,
+    $id: id,
+  }
+  const configManagerConfig = {
+    ...platformaticRuntime.configManagerConfig,
+    schema,
+  }
+  const wattpm = {
+    ...platformaticRuntime,
+    schema,
+    configManagerConfig,
+  }
+  store.add(wattpm)
+  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,26 @@
+'use strict'
+
+const pkg = require('../../package.json')
+
+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
+    }
+
+    config.$schema = `https://schemas.platformatic.dev/@platformatic/runtime/${pkg.version}.json`
+
+    if (config.server?.logger) {
+      config.logger = config.server.logger
+      delete config.server.logger
+    }
+
+    return config
+  }
+}