@platformatic/runtime 0.35.4 → 0.36.0

package/fixtures/stackables/node_modules/foo/foo.js

@@ -0,0 +1,61 @@
+'use strict'
+
+const { schema } = require('@platformatic/service')
+
+/**  @type {import('fastify').FastifyPluginAsync<{}>} */
+async function foo (app) {
+  const text = app.platformatic.config.foo.text
+  app.get('/foo', async (request, reply) => {
+    return text
+  })
+}
+
+foo.configType = 'foo'
+foo.schema = {
+  $id: 'https://example.com/schemas/foo.json',
+  title: 'Platformatic Service',
+  type: 'object',
+  properties: {
+    server: schema.server,
+    plugins: schema.plugins,
+    metrics: schema.metrics,
+    watch: {
+      anyOf: [schema.watch, {
+        type: 'boolean'
+      }, {
+        type: 'string'
+      }]
+    },
+    $schema: {
+      type: 'string'
+    },
+    module: {
+      type: 'string'
+    },
+    foo: {
+      type: 'object',
+      properties: {
+        text: {
+          type: 'string'
+        }
+      },
+      required: ['text']
+    }
+  },
+  additionalProperties: false,
+  required: ['server']
+}
+
+foo.configManagerConfig = {
+  schema: foo.schema,
+  envWhitelist: ['PORT', 'HOSTNAME'],
+  allowToWatch: ['.env'],
+  schemaOptions: {
+    useDefaults: true,
+    coerceTypes: true,
+    allErrors: true,
+    strict: false
+  }
+}
+
+module.exports = foo

package/fixtures/stackables/node_modules/foo/package.json

@@ -0,0 +1,4 @@
+{
+  "name": "foo",
+  "main": "foo.js"
+}

package/fixtures/stackables/platformatic.json

@@ -0,0 +1,11 @@
+{
+  "$schema": "https://example.com/schemas/foo.json",
+  "module": "foo",
+  "server": {
+    "port": 0,
+    "hostname": "127.0.0.1"
+  },
+  "foo": {
+    "text": "Hello World"
+  }
+}

package/lib/app.js

@@ -90,6 +90,7 @@ class PlatformaticApp {
       // If this is a restart, have the fastify server restart itself. If this
       // is not a restart, then create a new server.
       this.server = await buildServer({
+        app: this.config.app,
         ...config,
         configManager
       })
@@ -157,7 +158,7 @@ class PlatformaticApp {
 
     let _config
     try {
-      _config = await loadConfig({}, ['-c', appConfig.config], null, {
+      _config = await loadConfig({}, ['-c', appConfig.config], {
         watch: true,
         onMissingEnv (key) {
           return appConfig.localServiceEnvVars.get(key)

package/lib/compile.js

@@ -9,7 +9,7 @@ const pretty = require('pino-pretty')
 const { isatty } = require('node:tty')
 
 async function compile (argv, logger) {
-  const { configManager, configType } = await loadConfig({}, argv, undefined, {
+  const { configManager, configType } = await loadConfig({}, argv, {
     watch: false
   })
 
@@ -33,7 +33,7 @@ async function compile (argv, logger) {
     for (const service of configManager.current.services) {
       const childLogger = logger.child({ name: service.id })
 
-      const serviceConfig = await loadConfig({}, argv, undefined, {
+      const serviceConfig = await loadConfig({}, argv, {
         watch: false
       })
 

package/lib/start.js

@@ -5,7 +5,7 @@ const { join } = require('node:path')
 const { pathToFileURL } = require('node:url')
 const { Worker } = require('node:worker_threads')
 const closeWithGrace = require('close-with-grace')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { parseInspectorOptions, platformaticRuntime } = require('./config')
 const RuntimeApiClient = require('./api-client.js')
 const kLoaderFile = pathToFileURL(join(__dirname, 'loader.mjs')).href

package/lib/unified-api.js

@@ -1,112 +1,41 @@
 'use strict'
-const { resolve } = require('node:path')
-const parseArgs = require('minimist')
-const ConfigManager = require('@platformatic/config')
+const { Store, loadConfig, printConfigValidationErrors } = require('@platformatic/config')
 const {
   platformaticService,
   buildServer,
-  loadConfig,
-  start,
-  schema: serviceSchema
+  start
 } = require('@platformatic/service')
 const {
-  schema: dbSchema,
   platformaticDB
 } = require('@platformatic/db')
 const {
-  schema: composerSchema,
   platformaticComposer
 } = require('@platformatic/composer')
 const { buildServer: runtimeBuildServer } = require('./build-server')
 const { platformaticRuntime, wrapConfigInRuntimeConfig } = require('./config')
-const { schema: runtimeSchema } = require('./schema')
 const {
   start: runtimeStart,
   startWithConfig: runtimeStartWithConfig
 } = require('./start')
 
-const kSupportedAppTypes = new Set(['service', 'db', 'composer', 'runtime'])
+const store = new Store()
+store.add(platformaticService)
+store.add(platformaticDB)
+store.add(platformaticComposer)
+store.add(platformaticRuntime)
 
-async function tryGetConfigTypeFromSchema (config) {
-  /* c8 ignore next 6 - c8 is not seeing this as covered for some reason. */
-  if (typeof config === 'string') {
-    // Handle config file paths.
-    const loadedConfig = await loadConfig({}, ['-c', config], platformaticService)
-
-    config = loadedConfig.configManager.current
-  }
-
-  const schema = config?.$schema
-
-  if (typeof schema !== 'string') {
-    throw new Error('configuration is missing a schema')
-  }
-
-  const configType = schema.split('/').pop()
-
-  if (!kSupportedAppTypes.has(configType)) {
-    throw new Error(`unknown configuration type: '${configType}'`)
-  }
-
-  return configType
-}
-
-async function getConfigType (args = [], directory) {
-  try {
-    // The config type was not specified, so we need to figure it out.
-    // Try to get the config file from the provided arguments.
-    let { config } = parseArgs(args, { alias: { c: 'config' } })
-
-    if (!config) {
-      // Couldn't get the config file from the arguments, so look in the
-      // provided directory (or current directory) for any recognized
-      // config files.
-      const searchDir = directory ?? process.cwd()
-      const configFile = await ConfigManager.findConfigFile(searchDir)
-
-      config = resolve(searchDir, configFile)
-    }
-
-    // At this point, we have the config file. However, several different
-    // file formats are supported, so use the config manager to parse the
-    // file (without worrying about the validity of the file). We can then
-    // use the $schema field to determine the config type.
-    const configManager = new ConfigManager({ source: config })
-    const configString = await configManager.load()
-    const parsedConfig = configManager._parser(configString)
-
-    return await tryGetConfigTypeFromSchema(parsedConfig)
-  } catch (err) {
-    const configFiles = ConfigManager.listConfigFiles()
-    const msg = `
-Missing config file!
-Be sure to have a config file with one of the following names:
-${configFiles.map((s) => ' * ' + s).join('\n')}
-Alternatively run "npm create platformatic@latest" to generate a basic plt service config.
-`
-
-    throw new Error(msg, { cause: err })
-  }
-}
-
-async function getCurrentSchema (configType) {
-  if (configType === 'service') {
-    return serviceSchema.schema
-  } else if (configType === 'db') {
-    return dbSchema
-  } else if (configType === 'composer') {
-    return composerSchema
-  } else if (configType === 'runtime') {
-    return runtimeSchema
+/* c8 ignore next 10 - for some reason c8 is not seeing this as covered. */
+async function _buildServer (options) {
+  if (typeof options === 'string') {
+    const config = await _loadConfig({}, ['-c', options])
+    options = config.configManager.current
+    options.configManager = config.configManager
+    options.app = config.app
   }
 
-  throw new Error(`unknown configuration type: '${configType}'`)
-}
+  const app = options.app
 
-/* c8 ignore next 10 - for some reason c8 is not seeing this as covered. */
-async function _buildServer (options) {
-  const configType = await tryGetConfigTypeFromSchema(options)
-  const app = getApp(configType)
+  delete options.app
 
   if (app === platformaticRuntime) {
     return runtimeBuildServer(options)
@@ -115,51 +44,26 @@ async function _buildServer (options) {
   return buildServer(options, app)
 }
 
-function getApp (configType) {
-  if (configType === 'service') {
-    return platformaticService
-  } else if (configType === 'db') {
-    return platformaticDB
-  } else if (configType === 'composer') {
-    return platformaticComposer
-  } else if (configType === 'runtime') {
-    return platformaticRuntime
-  }
-
-  throw new Error('unknown kind: ' + configType)
-}
-
-async function _loadConfig (minimistConfig, args, configType, overrides) {
-  // If the config type was specified, then use that. Otherwise, compute it.
-  if (typeof configType !== 'string') {
-    configType = await getConfigType(args)
-  }
-
-  const app = getApp(configType)
-  const res = await loadConfig(minimistConfig, args, app, overrides)
-  res.configType = configType
-  res.app = app
-
-  return res
+function _loadConfig (minimistConfig, args, overrides) {
+  return loadConfig(minimistConfig, args, store, overrides)
 }
 
 async function _start (args) {
-  const configType = await getConfigType(args)
+  const config = await _loadConfig({}, args)
 
-  if (configType === 'runtime') {
+  if (config.configType === 'runtime') {
     return runtimeStart(args)
   }
 
-  return start(getApp(configType), args)
+  return start(config.app, args)
 }
 
 async function startCommand (args) {
   try {
-    const configType = await getConfigType(args)
-    const config = await _loadConfig({}, args, configType)
+    const config = await _loadConfig({}, args)
     let runtime
 
-    if (configType === 'runtime') {
+    if (config.configType === 'runtime') {
       config.configManager.args = config.args
       runtime = await runtimeStartWithConfig(config.configManager)
     } else {
@@ -175,6 +79,19 @@ async function startCommand (args) {
 }
 
 function logErrorAndExit (err) {
+  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)
+  }
+
   delete err?.stack
   console.error(err?.message)
 
@@ -187,10 +104,7 @@ function logErrorAndExit (err) {
 
 module.exports = {
   buildServer: _buildServer,
-  getConfigType,
-  getCurrentSchema,
   loadConfig: _loadConfig,
   start: _start,
-  startCommand,
-  getApp
+  startCommand
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@platformatic/runtime",
-  "version": "0.35.4",
+  "version": "0.36.0",
   "description": "",
   "main": "index.js",
   "bin": {
@@ -24,8 +24,8 @@
     "standard": "^17.1.0",
     "tsd": "^0.28.1",
     "typescript": "^5.1.6",
-    "@platformatic/sql-graphql": "0.35.4",
-    "@platformatic/sql-mapper": "0.35.4"
+    "@platformatic/sql-graphql": "0.36.0",
+    "@platformatic/sql-mapper": "0.36.0"
   },
   "dependencies": {
     "@hapi/topo": "^6.0.2",
@@ -42,12 +42,12 @@
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "undici": "^5.22.1",
-    "@platformatic/composer": "0.35.4",
-    "@platformatic/config": "0.35.4",
-    "@platformatic/db": "0.35.4",
-    "@platformatic/service": "0.35.4",
-    "@platformatic/telemetry": "0.35.4",
-    "@platformatic/utils": "0.35.4"
+    "@platformatic/composer": "0.36.0",
+    "@platformatic/db": "0.36.0",
+    "@platformatic/config": "0.36.0",
+    "@platformatic/service": "0.36.0",
+    "@platformatic/telemetry": "0.36.0",
+    "@platformatic/utils": "0.36.0"
   },
   "standard": {
     "ignore": [

package/test/api.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
 
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { buildServer, platformaticRuntime } = require('..')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 

package/test/cli/start.test.mjs

@@ -115,3 +115,13 @@ test('starts the inspector', async (t) => {
   assert(found)
   child.kill('SIGINT')
 })
+
+test('stackable', async () => {
+  const config = join(import.meta.url, '..', '..', 'fixtures', 'stackables', 'platformatic.json')
+  const { child, url } = await start('start', '-c', config)
+  const res = await request(url + '/foo')
+
+  assert.strictEqual(res.statusCode, 200)
+  assert.deepStrictEqual(await res.body.text(), 'Hello World')
+  child.kill('SIGINT')
+})

package/test/config.test.js

@@ -3,7 +3,8 @@
 const assert = require('node:assert')
 const { join } = require('node:path')
 const { test } = require('node:test')
-const { loadConfig, platformaticService } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
+const { platformaticService } = require('@platformatic/service')
 const { parseInspectorOptions, platformaticRuntime } = require('../lib/config')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 

package/test/start.test.js

@@ -6,7 +6,8 @@ const { join } = require('node:path')
 const { test } = require('node:test')
 const { MessageChannel } = require('node:worker_threads')
 const { request } = require('undici')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
+const { platformaticDB } = require('@platformatic/db')
 const { buildServer, platformaticRuntime } = require('..')
 const { wrapConfigInRuntimeConfig } = require('../lib/config')
 const { startWithConfig } = require('../lib/start')
@@ -160,7 +161,7 @@ test('handles uncaught exceptions with db app', async (t) => {
 
 test('logs errors during db migrations', async (t) => {
   const configFile = join(fixturesDir, 'dbAppWithMigrationError', 'platformatic.db.json')
-  const config = await loadConfig({}, ['-c', configFile], 'db')
+  const config = await loadConfig({}, ['-c', configFile], platformaticDB)
   const runtimeConfig = await wrapConfigInRuntimeConfig(config)
   const { port1, port2 } = new MessageChannel()
   runtimeConfig.current.loggingPort = port2

package/test/telemetry.test.js

@@ -4,7 +4,7 @@ const assert = require('node:assert')
 const { request } = require('undici')
 const { test } = require('node:test')
 const { join } = require('node:path')
-const { loadConfig } = require('@platformatic/service')
+const { loadConfig } = require('@platformatic/config')
 const { platformaticRuntime } = require('..')
 const { startWithConfig } = require('../lib/start')
 const fixturesDir = join(__dirname, '..', 'fixtures')

package/test/unified-api.test.js

@@ -6,117 +6,10 @@ const { join } = require('node:path')
 const { test } = require('node:test')
 const {
   buildServer,
-  getConfigType,
-  getCurrentSchema,
   loadConfig
 } = require('../lib/unified-api')
-const { version } = require('../package.json')
 const fixturesDir = join(__dirname, '..', 'fixtures')
 
-test('getConfigType()', async (t) => {
-  await t.test('throws if there is no $schema', async () => {
-    const configFile = join(fixturesDir, 'configs', 'no-schema.config.json')
-    let err
-
-    try {
-      await getConfigType(['-c', configFile])
-    } catch (error) {
-      err = error
-    }
-
-    assert(err)
-    assert.strictEqual(err.cause.message, 'configuration is missing a schema')
-  })
-
-  await t.test('throws if the schema type is unsupported', async () => {
-    const configFile = join(fixturesDir, 'configs', 'invalid-schema-type.config.json')
-    let err
-
-    try {
-      await getConfigType(['-c', configFile])
-    } catch (error) {
-      err = error
-    }
-
-    assert(err)
-    assert.strictEqual(err.cause.message, 'unknown configuration type: \'trickortreat\'')
-  })
-
-  await t.test('gets type from config via args', async () => {
-    const configFile = join(fixturesDir, 'monorepo', 'serviceApp', 'platformatic.service.json')
-    const type = await getConfigType(['-c', configFile])
-
-    assert.strictEqual(type, 'service')
-  })
-
-  await t.test('gets type from config in provided directory', async () => {
-    const configDir = join(fixturesDir, 'monorepo', 'serviceApp')
-    const type = await getConfigType(undefined, configDir)
-
-    assert.strictEqual(type, 'service')
-  })
-
-  await t.test('gets db type from config in cwd', async (t) => {
-    const cwd = process.cwd()
-
-    t.after(() => {
-      process.chdir(cwd)
-    })
-
-    const configDir = join(fixturesDir, 'dbApp')
-    process.chdir(configDir)
-    const type = await getConfigType()
-
-    assert.strictEqual(type, 'db')
-  })
-
-  await t.test('gets composer type from config in cwd', async (t) => {
-    const cwd = process.cwd()
-
-    t.after(() => {
-      process.chdir(cwd)
-    })
-
-    const configDir = join(fixturesDir, 'monorepo', 'composerApp')
-    process.chdir(configDir)
-    const type = await getConfigType()
-
-    assert.strictEqual(type, 'composer')
-  })
-})
-
-test('getCurrentSchema()', async (t) => {
-  await t.test('gets service schema', async () => {
-    const schema = await getCurrentSchema('service')
-
-    assert(schema.$id.endsWith(`/v${version}/service`))
-  })
-
-  await t.test('gets db schema', async () => {
-    const schema = await getCurrentSchema('db')
-
-    assert(schema.$id.endsWith(`/v${version}/db`))
-  })
-
-  await t.test('gets composer schema', async () => {
-    const schema = await getCurrentSchema('composer')
-
-    assert(schema.$id.endsWith(`/v${version}/composer`))
-  })
-
-  await t.test('gets runtime schema', async () => {
-    const schema = await getCurrentSchema('runtime')
-
-    assert(schema.$id.endsWith(`/v${version}/runtime`))
-  })
-
-  await t.test('throws for unknown types', async () => {
-    await assert.rejects(async () => {
-      await getCurrentSchema('not-a-real-type')
-    }, /unknown configuration type/)
-  })
-})
-
 test('loadConfig()', async (t) => {
   await t.test('can explicitly provide config type', async () => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
@@ -128,18 +21,6 @@ test('loadConfig()', async (t) => {
     assert.strictEqual(config.configManager.schemaOptions.useDefaults, true)
   })
 
-  await t.test('throws if explicit type is wrong', async () => {
-    // Prevent the failed validation from logging and exiting the process.
-    t.mock.method(process, 'exit', () => {})
-    t.mock.method(console, 'table', () => {})
-
-    const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
-
-    await assert.rejects(async () => {
-      await loadConfig({}, ['-c', configFile], 'kaboom')
-    })
-  })
-
   await t.test('can load a platformatic service project', async () => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
     const config = await loadConfig({}, ['-c', configFile])
@@ -182,7 +63,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a service server', async (t) => {
     const configFile = join(fixturesDir, 'monorepo', 'serviceAppWithLogger', 'platformatic.service.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -196,7 +80,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a db server', async (t) => {
     const configFile = join(fixturesDir, 'dbApp', 'platformatic.db.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -210,7 +97,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a composer server', async (t) => {
     const configFile = join(fixturesDir, 'composerApp', 'platformatic.composer.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -224,7 +114,10 @@ test('buildServer()', async (t) => {
   await t.test('can build a runtime application', async (t) => {
     const configFile = join(fixturesDir, 'configs', 'monorepo.json')
     const config = await loadConfig({}, ['-c', configFile])
-    const server = await buildServer(config.configManager.current)
+    const server = await buildServer({
+      app: config.app,
+      ...config.configManager.current
+    })
 
     t.after(async () => {
       await server.close()
@@ -244,6 +137,9 @@ test('buildServer()', async (t) => {
     })
 
     const address = await server.start()
+
+    assert.strictEqual(server.platformatic.configManager.fullPath, configFile)
+
     // The address should be a valid URL.
     new URL(address) // eslint-disable-line no-new
   })