@platformatic/runtime 3.4.1 → 3.5.1

package/help/compile.txt

@@ -1,8 +0,0 @@
-Compile all typescript plugins for all services.
-
-``` bash
-  $ platformatic runtime compile
-```
-
-This command will compile the TypeScript
-plugins for each services registered in the runtime.

package/help/help.txt

@@ -1,5 +0,0 @@
-Available commands:
-
-* `help` - show this help message.
-* `help <command>` - shows more information about a command.
-* `start` - start the application.

package/help/start.txt

@@ -1,21 +0,0 @@
-Start the Platformatic Runtime with the following command:
-
-```bash
- $ platformatic runtime start
-```
-
-You can also specify a custom routes file, for example:
-
-```bash
- $ platformatic runtime start routes.js
-```
-
-Where `routes.js` is:
-
-```javascript
-module.exports = async function (app) {
-  app.get('/hello', async () => {
-    return { hello: 'hello123' }
-  })
-}
-```

package/index.test-d.ts

@@ -1,41 +0,0 @@
-import { expectError, expectType } from 'tsd'
-import { LightMyRequestResponse } from 'fastify'
-import { pltRuntimeBuildServer, errors } from '.'
-import { FastifyError } from '@fastify/error'
-
-const server: pltRuntimeBuildServer = {
-  address: 'localhost',
-  port: 3000,
-  restart: async () => { },
-  stop: async () => { },
-  inject: async () => ({} as LightMyRequestResponse),
-}
-
-expectType<pltRuntimeBuildServer>(server)
-expectError<pltRuntimeBuildServer>({ ...server, address: 42 })
-expectError<pltRuntimeBuildServer>({ ...server, port: 'WRONG' })
-expectError<pltRuntimeBuildServer>({ ...server, restart: 'WRONG' })
-expectError<pltRuntimeBuildServer>({ ...server, stop: 'WRONG' })
-expectError<pltRuntimeBuildServer>({ ...server, inject: 'WRONG' })
-
-// Errors
-type ErrorWithNoParams = () => FastifyError
-type ErrorWithOneParam = (param: string) => FastifyError
-type ErrorWithTwoParams = (param1: string, param2: string) => FastifyError
-
-expectType<ErrorWithNoParams>(errors.RuntimeExitedError)
-expectType<ErrorWithOneParam>(errors.UnknownRuntimeAPICommandError)
-expectType<ErrorWithOneParam>(errors.ServiceNotFoundError)
-expectType<ErrorWithOneParam>(errors.ServiceNotStartedError)
-expectType<ErrorWithTwoParams>(errors.FailedToRetrieveOpenAPISchemaError)
-expectType<ErrorWithNoParams>(errors.ApplicationAlreadyStartedError)
-expectType<ErrorWithNoParams>(errors.ApplicationNotStartedError)
-expectType<ErrorWithNoParams>(errors.ConfigPathMustBeStringError)
-expectType<ErrorWithOneParam>(errors.NoConfigFileFoundError)
-expectType<ErrorWithOneParam>(errors.InvalidEntrypointError)
-expectType<ErrorWithOneParam>(errors.MissingDependencyError)
-expectType<ErrorWithNoParams>(errors.InspectAndInspectBrkError)
-expectType<ErrorWithNoParams>(errors.InspectorPortError)
-expectType<ErrorWithNoParams>(errors.InspectorHostError)
-expectType<ErrorWithOneParam>(errors.CannotMapSpecifierToAbsolutePathError)
-expectType<ErrorWithNoParams>(errors.NodeInspectorFlagsNotSupportedError)

package/lib/build-server.js

@@ -1,69 +0,0 @@
-'use strict'
-
-const { createRequire } = require('node:module')
-const { join } = require('node:path')
-
-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,98 +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/dependencies.js

@@ -1,59 +0,0 @@
-'use strict'
-
-const Topo = require('@hapi/topo')
-const { closest } = require('fastest-levenshtein')
-
-const errors = require('./errors')
-
-function missingDependencyErrorMessage (clientName, service, services) {
-  const closestName = closest(clientName, [...services.keys()])
-  let errorMsg = `service '${service.id}' has unknown dependency: '${clientName}'.`
-  if (closestName) {
-    errorMsg += ` Did you mean '${closestName}'?`
-  }
-  return errorMsg
-}
-
-function checkDependencies (services) {
-  const allServices = new Set(services.map(s => s.id))
-
-  for (const service of services) {
-    for (const dependency of service.dependencies) {
-      if (dependency.local && !allServices.has(dependency.id)) {
-        throw new errors.MissingDependencyError(
-          missingDependencyErrorMessage(dependency.id, service, services)
-        )
-      }
-    }
-  }
-}
-
-function topologicalSort (services, config) {
-  const topo = new Topo.Sorter()
-
-  for (const service of config.services) {
-    const localDependencyIds = Array.from(service.dependencies)
-      .filter(dep => dep.local)
-      .map(dep => dep.id)
-
-    topo.add(service, {
-      group: service.id,
-      after: localDependencyIds,
-      manual: true,
-    })
-  }
-
-  config.services = topo.sort()
-
-  return new Map(Array.from(services.entries()).sort((a, b) => {
-    if (a[0] === b[0]) {
-      return 0
-    }
-
-    const aIndex = config.services.findIndex(s => s.id === a[0])
-    const bIndex = config.services.findIndex(s => s.id === b[0])
-    return aIndex - bIndex
-  }))
-}
-
-module.exports = { checkDependencies, topologicalSort }

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>
-  }
-}