@platformatic/runtime 2.74.3 → 3.0.0-alpha.2

package/lib/build-server.js

@@ -1,67 +0,0 @@
-'use strict'
-
-const { join } = require('node:path')
-const { createRequire } = require('node:module')
-const ConfigManager = require('@platformatic/config')
-const { platformaticRuntime } = require('./config')
-const { buildRuntime } = require('./start')
-const { loadConfig } = require('./utils')
-
-async function buildServerRuntime (options = {}, args = undefined) {
-  const { serviceMap } = options
-
-  if (!options.configManager) {
-    delete options.serviceMap
-
-    // Instantiate a new config manager from the current options.
-    const cm = new ConfigManager({
-      ...platformaticRuntime.configManagerConfig,
-      source: options
-    })
-    await cm.parseAndValidate()
-
-    cm.current.serviceMap = serviceMap
-
-    if (typeof options === 'string') {
-      options = { configManager: cm }
-    } else {
-      options.configManager = cm
-    }
-  }
-
-  if (args) {
-    options.configManager.args = args
-  }
-
-  return buildRuntime(options.configManager, options.env)
-}
-
-async function buildServer (options, args) {
-  if (typeof options === 'string') {
-    const config = await loadConfig({}, ['-c', options])
-    options = config.configManager.current
-    options.configManager = config.configManager
-    options.app = config.app
-  }
-
-  const app = options.app
-
-  delete options.app
-
-  if (app === platformaticRuntime || !app) {
-    return buildServerRuntime(options, args)
-  }
-
-  if (app.buildServer) {
-    return app.buildServer(options)
-  }
-
-  // App is a stackable. Hopefully we have `@platformatic/service` available.
-  const projectRoot = join(options.configManager.dirname, 'package.json')
-  const require = createRequire(projectRoot)
-  const { buildServer } = require('@platformatic/service')
-
-  return buildServer(options, app)
-}
-
-module.exports = { buildServer }

package/lib/compile.js

@@ -1,108 +0,0 @@
-'use strict'
-
-const { createRequire } = require('node:module')
-const { dirname, join } = require('node:path')
-const { isatty } = require('node:tty')
-const { pathToFileURL } = require('node:url')
-
-const tsCompiler = require('@platformatic/ts-compiler')
-const pino = require('pino')
-const pretty = require('pino-pretty')
-
-const { loadConfig } = require('./utils')
-
-async function compile (argv, logger) {
-  const { configManager, configType, app } = await loadConfig(
-    {},
-    argv,
-    {
-      watch: false
-    },
-    false
-  )
-  /* c8 ignore next */
-  if (!logger) {
-    let stream
-
-    if (isatty(process.stdout.fd)) {
-      stream = pretty({
-        translateTime: 'SYS:HH:MM:ss',
-        ignore: 'hostname,pid'
-      })
-    }
-
-    logger = pino(stream)
-  }
-
-  let compiled = false
-  const compileOptions = {
-    clean: argv.includes('--clean')
-  }
-  if (configType === 'runtime') {
-    for (const service of configManager.current.services) {
-      const childLogger = logger.child({ name: service.id })
-
-      const serviceConfigPath = service.config
-      const { configManager, app } = await loadConfig(
-        {},
-        ['-c', serviceConfigPath],
-        {
-          onMissingEnv (key) {
-            return service.localServiceEnvVars.get(key)
-          },
-          watch: false
-        },
-        false
-      )
-
-      const tsOptions = await extract(configManager, app)
-
-      if (tsOptions) {
-        const serviceWasCompiled = await tsCompiler.compile({
-          ...compileOptions,
-          ...tsOptions,
-          cwd: service.path,
-          logger: childLogger
-        })
-        compiled ||= serviceWasCompiled
-      }
-    }
-  } else {
-    const tsOptions = await extract(configManager, app)
-    if (tsOptions) {
-      compiled = await tsCompiler.compile({
-        ...compileOptions,
-        ...tsOptions,
-        cwd: dirname(configManager.fullPath),
-        logger
-      })
-    }
-  }
-
-  return compiled
-}
-
-async function extract (configManager, app) {
-  let extractTypeScriptCompileOptionsFromConfig = app.extractTypeScriptCompileOptionsFromConfig
-
-  if (!extractTypeScriptCompileOptionsFromConfig) {
-    // This is a bit of a hack, but it is needed to avoid a circular dependency
-    // it also allow for customizations if needed
-    const _require = createRequire(join(configManager.dirname, 'package.json'))
-    const toLoad = _require.resolve('@platformatic/service')
-    try {
-      extractTypeScriptCompileOptionsFromConfig = (await import(pathToFileURL(toLoad)))
-        .extractTypeScriptCompileOptionsFromConfig
-    } catch {}
-    // If we can't load `@platformatic/service` we just return null
-    // and we won't be compiling typescript
-  }
-
-  if (!extractTypeScriptCompileOptionsFromConfig) {
-    return null
-  }
-
-  return extractTypeScriptCompileOptionsFromConfig(configManager.current)
-}
-
-module.exports.compile = compile

package/lib/generator/README.md

@@ -1,32 +0,0 @@
-# Platformatic Runtime API
-
-This is a generated [Platformatic Runtime](https://docs.platformatic.dev/docs/runtime/overview) application.
-
-## Requirements
-
-Platformatic supports macOS, Linux and Windows ([WSL](https://docs.microsoft.com/windows/wsl/) recommended).
-You'll need to have [Node.js](https://nodejs.org/) >= v18.8.0 or >= v20.6.0
-
-## Setup
-
-1. Install dependencies:
-
-```bash
-npm install
-```
-
-## Usage
-
-Run the API with:
-
-```bash
-npm start
-```
-
-## Adding a Service
-
-Adding a new service to this project is as simple as running `create-platformatic` again, like so:
-
-```
-npx create-platformatic
-```

package/lib/generator/errors.js

@@ -1,10 +0,0 @@
-'use strict'
-
-const createError = require('@fastify/error')
-
-const ERROR_PREFIX = 'PLT_RUNTIME_GEN'
-
-module.exports = {
-  NoServiceNamedError: createError(`${ERROR_PREFIX}_NO_SERVICE_FOUND`, 'No service named \'%s\' has been added to this runtime.'),
-  NoEntryPointError: createError(`${ERROR_PREFIX}_NO_ENTRYPOINT`, 'No entrypoint had been defined.'),
-}

package/lib/generator/runtime-generator.d.ts

@@ -1,37 +0,0 @@
-import { BaseGenerator } from '@platformatic/generators'
-import { FileGenerator } from '@platformatic/generators/lib/file-generator'
-
-type Service = {
-  config: FileGenerator.FileGenerator | BaseGenerator.BaseGenerator
-}
-type GeneratorMetadata = {
-  targetDirectory: string
-  env: KeyValue
-}
-
-type KeyValue = {
-  [key: string]: string
-}
-
-type RuntimeGeneratorOptions = BaseGenerator.BaseGeneratorOptions & {
-  logLevel: string
-}
-
-export namespace RuntimeGenerator {
-  export class RuntimeGenerator extends BaseGenerator.BaseGenerator {
-    services: Service[]
-    entryPoint: Service
-    constructor (opts?: RuntimeGeneratorOptions)
-
-    addService (service: Service, name: string): Promise<void>
-
-    setEntryPoint (entryPoint: string): void
-
-    setServicesDirectory (): void
-
-    setServicesConfig (configToOverride: object): void
-
-    getRuntimeEnv (): KeyValue
-    writeServicesFiles (): Promise<GeneratorMetadata>
-  }
-}

package/lib/start.js

@@ -1,211 +0,0 @@
-'use strict'
-
-const inspector = require('node:inspector')
-const { writeFile } = require('node:fs/promises')
-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 pino = require('pino')
-const pretty = require('pino-pretty')
-
-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 restartRuntime (runtime) {
-  runtime.logger.info('Received SIGUSR2, restarting all services ...')
-
-  try {
-    await runtime.restart()
-  } catch (err) {
-    runtime.logger.error({ err: ensureLoggableError(err) }, 'Failed to restart services.')
-  }
-}
-
-async function buildRuntime (configManager, env) {
-  env = env || Object.assign({}, process.env, configManager.env)
-
-  if (inspector.url() && !env.VSCODE_INSPECTOR_OPTIONS) {
-    throw new errors.NodeInspectorFlagsNotSupportedError()
-  }
-
-  if (configManager.args) {
-    parseInspectorOptions(configManager)
-  }
-
-  const dirname = configManager.dirname
-  const runtimeLogsDir = getRuntimeLogsDir(dirname, process.pid)
-
-  const runtime = new Runtime(configManager, runtimeLogsDir, env)
-
-  /* c8 ignore next 3 */
-  const restartListener = restartRuntime.bind(null, runtime)
-  process.on('SIGUSR2', restartListener)
-  runtime.on('closed', () => {
-    process.removeListener('SIGUSR2', restartListener)
-  })
-
-  try {
-    await runtime.init()
-  } catch (e) {
-    await runtime.close()
-    throw e
-  }
-
-  return runtime
-}
-
-async function start (args) {
-  const config = await loadConfig({}, args)
-
-  if (config.configType !== 'runtime') {
-    const configManager = await wrapConfigInRuntimeConfig(config)
-    config.configManager = configManager
-  }
-
-  const app = await buildRuntime(config.configManager)
-  await app.start()
-  return app
-}
-
-async function setupAndStartRuntime (config) {
-  const MAX_PORT = 65535
-  let runtimeConfig
-
-  if (config.configType === 'runtime') {
-    config.configManager.args = config.args
-    runtimeConfig = config.configManager
-  } else {
-    const wrappedConfig = await wrapConfigInRuntimeConfig(config)
-    wrappedConfig.args = config.args
-    runtimeConfig = wrappedConfig
-  }
-
-  let runtime = await buildRuntime(runtimeConfig)
-
-  let address = null
-  const startErr = null
-
-  runtimeConfig.current.server ??= { port: 0 }
-  let port = runtimeConfig.current.server.port
-  while (address === null) {
-    try {
-      address = await runtime.start()
-    } catch (err) {
-      if (err.code === 'EADDRINUSE' || err.code === 'EACCES') {
-        // Get the actual port from the error message if original port was 0
-        if (!port) {
-          const mo = err.message.match(/ address already in use (.+)/)
-          const url = new URL(`http://${mo[1]}`)
-          port = Number(url.port)
-        }
-
-        port++
-        await runtime.close()
-
-        if (port > MAX_PORT) {
-          throw err
-        }
-
-        runtimeConfig.current.server.port = port
-        runtime = await buildRuntime(runtimeConfig)
-      } else {
-        throw err
-      }
-    }
-  }
-  if (startErr?.code === 'PLT_RUNTIME_EADDR_IN_USE') {
-    const logger = pino(
-      pretty({
-        translateTime: 'SYS:HH:MM:ss',
-        ignore: 'hostname,pid'
-      })
-    )
-    logger.warn(`Port: ${port} is already in use!`)
-    logger.warn(`Changing the port to ${runtimeConfig.current.server.port}`)
-  }
-  return { address, runtime }
-}
-
-async function startCommand (args, throwAllErrors = false, returnRuntime = false) {
-  try {
-    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 => {
-      if (event.err instanceof Error) {
-        console.error(event.err)
-      }
-      await runtime.close()
-    })
-
-    return returnRuntime ? runtime : res
-  } catch (err) {
-    if (throwAllErrors && err.code !== 'PLT_RUNTIME_RUNTIME_ABORT') {
-      throw err
-    }
-
-    if (err.code === 'PLT_CONFIG_NO_CONFIG_FILE_FOUND' && args.length === 1) {
-      const config = {
-        $schema: `https://schemas.platformatic.dev/@platformatic/service/${pkg.version}.json`,
-        server: {
-          hostname: '127.0.0.1',
-          port: 3042,
-          logger: {
-            level: 'info'
-          }
-        },
-        plugins: {
-          paths: [args[0]]
-        },
-        service: {
-          openapi: true
-        },
-        watch: true
-      }
-      const toWrite = join(dirname(resolve(args[0])), 'platformatic.service.json')
-      console.log(`No config file found, creating ${join(dirname(args[0]), 'platformatic.service.json')}`)
-      await writeFile(toWrite, JSON.stringify(config, null, 2))
-      return startCommand(['--config', toWrite])
-    }
-
-    if (err.filenames) {
-      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')}
-
-  In alternative run "npm create platformatic@latest" to generate a basic plt service config.`)
-      process.exit(1)
-    } else if (err.validationErrors) {
-      printConfigValidationErrors(err)
-      process.exit(1)
-    }
-
-    if (err.code !== 'PLT_RUNTIME_RUNTIME_ABORT') {
-      console.error(err)
-    }
-
-    process.exit(1)
-  }
-}
-
-module.exports = { buildRuntime, start, startCommand, setupAndStartRuntime }

package/lib/worker/default-stackable.js

@@ -1,33 +0,0 @@
-'use strict'
-
-const defaultStackable = {
-  init: () => {},
-  start: () => {
-    throw new Error('Stackable start not implemented')
-  },
-  stop: () => {},
-  build: () => {},
-  getUrl: () => null,
-  updateContext: () => {},
-  getConfig: () => null,
-  getEnv: () => null,
-  getInfo: () => null,
-  getDispatchFunc: () => null,
-  getDispatchTarget: () => null,
-  getOpenapiSchema: () => null,
-  getGraphqlSchema: () => null,
-  getCustomHealthCheck: () => null,
-  getCustomReadinessCheck: () => null,
-  getMeta: () => ({}),
-  getMetrics: () => null,
-  inject: () => {
-    throw new Error('Stackable inject not implemented')
-  },
-  log: ({ message }) => {
-    console.log(message)
-  },
-  getBootstrapDependencies: () => [],
-  getWatchConfig: () => ({ enabled: false })
-}
-
-module.exports = defaultStackable

package/runtime.mjs

@@ -1,54 +0,0 @@
-#! /usr/bin/env node
-
-import { readFile } from 'node:fs/promises'
-import commist from 'commist'
-import { join } from 'desm'
-import isMain from 'es-main'
-import helpMe from 'help-me'
-import parseArgs from 'minimist'
-import { startCommand } from './index.js'
-import { compile as compileCmd } from './lib/compile.js'
-
-export const compile = compileCmd
-
-const help = helpMe({
-  dir: join(import.meta.url, 'help'),
-  // the default
-  ext: '.txt',
-})
-
-const program = commist({ maxDistance: 2 })
-
-program.register('help', help.toStdout)
-program.register('help start', help.toStdout.bind(null, ['start']))
-program.register('help compile', help.toStdout.bind(null, ['compile']))
-program.register('start', startCommand)
-program.register('compile', compile)
-
-export async function run (argv) {
-  const args = parseArgs(argv, {
-    alias: {
-      v: 'version',
-    },
-  })
-
-  if (args.version) {
-    console.log('v' + JSON.parse(await readFile(join(import.meta.url, 'package.json'), 'utf-8')).version)
-    process.exit(0)
-  }
-
-  /* c8 ignore next 4 */
-  return {
-    output: await program.parseAsync(argv),
-    help,
-  }
-}
-
-if (isMain(import.meta)) {
-  try {
-    await run(process.argv.slice(2))
-  } catch (err) {
-    console.error(err)
-    process.exit(1)
-  }
-}