create-platformatic 0.25.0 → 0.26.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "0.25.0",
+  "version": "0.26.1",
   "description": "Create platformatic-db interactive tool",
   "repository": {
     "type": "git",
@@ -15,6 +15,7 @@
   "license": "Apache-2.0",
   "author": "Marco Piraccini <marco.piraccini@gmail.com>",
   "dependencies": {
+    "boring-name-generator": "^1.0.3",
     "chalk": "^5.2.0",
     "commist": "^3.2.0",
     "desm": "^1.3.0",
@@ -25,14 +26,14 @@
     "inquirer": "^9.2.6",
     "log-update": "^5.0.1",
     "minimist": "^1.2.8",
-    "mkdirp": "^2.1.6",
     "ora": "^6.3.1",
     "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "pupa": "^3.1.0",
     "semver": "^7.5.1",
     "undici": "^5.22.1",
-    "@platformatic/config": "0.25.0"
+    "which": "^3.0.1",
+    "@platformatic/config": "0.26.1"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
@@ -44,8 +45,8 @@
     "standard": "^17.0.0",
     "tap": "^16.3.4",
     "yaml": "^2.2.2",
-    "@platformatic/db": "0.25.0",
-    "@platformatic/service": "0.25.0"
+    "@platformatic/db": "0.26.1",
+    "@platformatic/service": "0.26.1"
   },
   "scripts": {
     "test": "standard | snazzy && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" c8 --100 tap --no-coverage test/*test.mjs test/*/*test.mjs",

package/src/{ask-project-dir.mjs → ask-dir.mjs}

@@ -2,11 +2,11 @@ import { validatePath } from './utils.mjs'
 import inquirer from 'inquirer'
 import { resolve } from 'path'
 
-const askProjectDir = async (logger, defaultName) => {
+const askProjectDir = async (logger, defaultName, message = 'Where would you like to create your project?') => {
   const options = await inquirer.prompt({
     type: 'input',
     name: 'dir',
-    message: 'Where would you like to create your project?',
+    message,
     default: defaultName,
     validate: validatePath
   })

package/src/cli-options.mjs

@@ -18,3 +18,17 @@ export const getUseTypescript = typescript => {
     choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
   }
 }
+
+let port = 3042
+export const getPort = (nextPort) => {
+  if (nextPort === undefined) {
+    nextPort = port++
+  }
+
+  return {
+    type: 'input',
+    name: 'port',
+    message: 'What port do you want to use?',
+    default: nextPort
+  }
+}

package/src/composer/README.md

@@ -0,0 +1,30 @@
+# Platformatic Composer API
+
+This is a generated [Platformatic Composer](https://oss.platformatic.dev/docs/reference/composer/introduction) 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
+
+## Setup
+
+1. Install dependencies:
+
+```bash
+npm install
+```
+
+## Usage
+
+Run the API with:
+
+```bash
+npm start
+```
+
+### Explore
+- ⚡ The Platformatic Composer server is running at http://localhost:3042/
+- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/
+
+

package/src/composer/create-composer-cli.mjs

@@ -0,0 +1,107 @@
+import { getVersion, getDependencyVersion, isFileAccessible } from '../utils.mjs'
+import { createPackageJson } from '../create-package-json.mjs'
+import { createGitignore } from '../create-gitignore.mjs'
+import { getPkgManager } from '../get-pkg-manager.mjs'
+import parseArgs from 'minimist'
+import { join } from 'path'
+import inquirer from 'inquirer'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { execa } from 'execa'
+import ora from 'ora'
+import createComposer from './create-composer.mjs'
+import askDir from '../ask-dir.mjs'
+import { askDynamicWorkspaceCreateGHAction, askStaticWorkspaceGHAction } from '../ghaction.mjs'
+import { getRunPackageManagerInstall, getPort } from '../cli-options.mjs'
+
+export const createReadme = async (logger, dir = '.') => {
+  const readmeFileName = join(dir, 'README.md')
+  let isReadmeExists = await isFileAccessible(readmeFileName)
+  if (isReadmeExists) {
+    logger.debug(`${readmeFileName} found, asking to overwrite it.`)
+    const { shouldReplace } = await inquirer.prompt([{
+      type: 'list',
+      name: 'shouldReplace',
+      message: 'Do you want to overwrite the existing README.md?',
+      default: true,
+      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
+    }])
+    isReadmeExists = !shouldReplace
+  }
+
+  if (isReadmeExists) {
+    logger.debug(`${readmeFileName} found, skipping creation of README.md file.`)
+    return
+  }
+
+  const readmeFile = new URL('README.md', import.meta.url)
+  const readme = await readFile(readmeFile, 'utf-8')
+  await writeFile(readmeFileName, readme)
+  logger.debug(`${readmeFileName} successfully created.`)
+}
+
+const createPlatformaticComposer = async (_args, opts) => {
+  const logger = opts.logger || pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+
+  const args = parseArgs(_args, {
+    default: {
+      hostname: '127.0.0.1'
+    },
+    alias: {
+      h: 'hostname',
+      p: 'port'
+    }
+  })
+
+  const version = await getVersion()
+  const pkgManager = getPkgManager()
+
+  const projectDir = opts.dir || await askDir(logger, '.')
+
+  const toAsk = [getPort(args.port)]
+
+  if (!opts.skipPackageJson) {
+    toAsk.push(getRunPackageManagerInstall(pkgManager))
+  }
+
+  const { runPackageManagerInstall, port } = await inquirer.prompt(toAsk)
+
+  // Create the project directory
+  await mkdir(projectDir, { recursive: true })
+
+  const params = {
+    hostname: args.hostname,
+    port
+  }
+
+  const env = await createComposer(params, logger, projectDir, version)
+
+  const fastifyVersion = await getDependencyVersion('fastify')
+
+  // Create the package.json, notes that we don't have the option for TS (yet) so we don't generate
+  // the package.json with the TS build
+  if (!opts.skipPackageJson) {
+    await createPackageJson('composer', version, fastifyVersion, logger, projectDir, false)
+  }
+  if (!opts.skipGitignore) {
+    await createGitignore(logger, projectDir)
+  }
+  await createReadme(logger, projectDir)
+
+  if (runPackageManagerInstall) {
+    const spinner = ora('Installing dependencies...').start()
+    await execa(pkgManager, ['install'], { cwd: projectDir })
+    spinner.succeed('...done!')
+  }
+
+  if (!opts.skipGitHubActions) {
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'composer', false, projectDir)
+    await askStaticWorkspaceGHAction(logger, env, 'composer', false, projectDir)
+  }
+}
+
+export default createPlatformaticComposer

package/src/composer/create-composer.mjs

@@ -0,0 +1,76 @@
+import { readFile, writeFile, appendFile } from 'fs/promises'
+import { findComposerConfigFile, isFileAccessible } from '../utils.mjs'
+import { join } from 'path'
+import * as desm from 'desm'
+
+function generateConfig (version) {
+  const config = {
+    $schema: `https://platformatic.dev/schemas/v${version}/composer`,
+    server: {
+      hostname: '{PLT_SERVER_HOSTNAME}',
+      port: '{PORT}',
+      logger: {
+        level: '{PLT_SERVER_LOGGER_LEVEL}'
+      }
+    },
+    composer: {
+      services: [{
+        id: 'example',
+        origin: '{PLT_EXAMPLE_ORIGIN}',
+        openapi: {
+          url: '/documentation/json'
+        }
+      }],
+      refreshTimeout: 1000
+    },
+    watch: true
+  }
+
+  return config
+}
+
+function generateEnv (hostname, port) {
+  const env = `\
+PLT_SERVER_HOSTNAME=${hostname}
+PORT=${port}
+PLT_SERVER_LOGGER_LEVEL=info
+PLT_EXAMPLE_ORIGIN=
+`
+
+  return env
+}
+
+async function createComposer ({ hostname, port }, logger, currentDir = process.cwd(), version) {
+  if (!version) {
+    const pkg = await readFile(desm.join(import.meta.url, '..', '..', 'package.json'))
+    version = JSON.parse(pkg).version
+  }
+  const accessibleConfigFilename = await findComposerConfigFile(currentDir)
+
+  if (accessibleConfigFilename === undefined) {
+    const config = generateConfig(version)
+    await writeFile(join(currentDir, 'platformatic.composer.json'), JSON.stringify(config, null, 2))
+    logger.info('Configuration file platformatic.composer.json successfully created.')
+
+    const env = generateEnv(hostname, port)
+    const envFileExists = await isFileAccessible('.env', currentDir)
+    await appendFile(join(currentDir, '.env'), env)
+    await writeFile(join(currentDir, '.env.sample'), env)
+    /* c8 ignore next 5 */
+    if (envFileExists) {
+      logger.info('Environment file .env found, appending new environment variables to existing .env file.')
+    } else {
+      logger.info('Environment file .env successfully created.')
+    }
+  } else {
+    logger.info(`Configuration file ${accessibleConfigFilename} found, skipping creation of configuration file.`)
+  }
+
+  return {
+    PLT_SERVER_LOGGER_LEVEL: 'info',
+    PORT: port,
+    PLT_SERVER_HOSTNAME: hostname
+  }
+}
+
+export default createComposer

package/src/create-gitignore.mjs

@@ -3,7 +3,7 @@ import { writeFile } from 'fs/promises'
 import { join } from 'node:path'
 
 const gitignore = `\
-dist 
+dist
 .DS_Store
 
 # dotenv environment variable files

package/src/db/create-db-cli.mjs

@@ -5,16 +5,16 @@ import { getPkgManager } from '../get-pkg-manager.mjs'
 import parseArgs from 'minimist'
 import { join } from 'path'
 import inquirer from 'inquirer'
-import { readFile, writeFile } from 'fs/promises'
+import which from 'which'
+import { readFile, writeFile, mkdir } from 'fs/promises'
 import pino from 'pino'
 import pretty from 'pino-pretty'
 import { execa } from 'execa'
 import ora from 'ora'
 import createDB from './create-db.mjs'
-import askProjectDir from '../ask-project-dir.mjs'
+import askDir from '../ask-dir.mjs'
 import { askDynamicWorkspaceCreateGHAction, askStaticWorkspaceGHAction } from '../ghaction.mjs'
-import { getRunPackageManagerInstall, getUseTypescript } from '../cli-options.mjs'
-import mkdirp from 'mkdirp'
+import { getRunPackageManagerInstall, getUseTypescript, getPort } from '../cli-options.mjs'
 
 export const createReadme = async (logger, dir = '.') => {
   const readmeFileName = join(dir, 'README.md')
@@ -42,11 +42,10 @@ export const createReadme = async (logger, dir = '.') => {
   logger.debug(`${readmeFileName} successfully created.`)
 }
 
-export const parseDBArgs = (_args) => {
+export function parseDBArgs (_args) {
   return parseArgs(_args, {
     default: {
       hostname: '127.0.0.1',
-      port: 3042,
       database: 'sqlite',
       migrations: 'migrations',
       plugin: true,
@@ -66,8 +65,8 @@ export const parseDBArgs = (_args) => {
   })
 }
 
-const createPlatformaticDB = async (_args) => {
-  const logger = pino(pretty({
+const createPlatformaticDB = async (_args, opts) => {
+  const logger = opts.logger || pino(pretty({
     translateTime: 'SYS:HH:MM:ss',
     ignore: 'hostname,pid'
   }))
@@ -75,7 +74,7 @@ const createPlatformaticDB = async (_args) => {
   const args = parseDBArgs(_args)
   const version = await getVersion()
   const pkgManager = getPkgManager()
-  const projectDir = await askProjectDir(logger, '.')
+  const projectDir = opts.dir || await askDir(logger, '.')
 
   const wizardOptions = await inquirer.prompt([{
     type: 'list',
@@ -90,11 +89,12 @@ const createPlatformaticDB = async (_args) => {
     default: args.plugin,
     choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
   },
-  getUseTypescript(args.typescript)
+  getUseTypescript(args.typescript),
+  getPort(args.port)
   ])
 
   // Create the project directory
-  await mkdirp(projectDir)
+  await mkdir(projectDir, { recursive: true })
 
   const generatePlugin = args.plugin || wizardOptions.generatePlugin
   const useTypescript = args.typescript || wizardOptions.useTypescript
@@ -102,7 +102,7 @@ const createPlatformaticDB = async (_args) => {
 
   const params = {
     hostname: args.hostname,
-    port: args.port,
+    port: wizardOptions.port,
     database: args.database,
     migrations: wizardOptions.defaultMigrations ? args.migrations : '',
     plugin: generatePlugin,
@@ -119,17 +119,35 @@ const createPlatformaticDB = async (_args) => {
   await createGitignore(logger, projectDir)
   await createReadme(logger, projectDir)
 
-  const { runPackageManagerInstall } = await inquirer.prompt([
-    getRunPackageManagerInstall(pkgManager)
-  ])
+  let hasPlatformaticInstalled = false
+  if (!opts.skipPackageJson) {
+    const { runPackageManagerInstall } = await inquirer.prompt([
+      getRunPackageManagerInstall(pkgManager)
+    ])
+
+    if (runPackageManagerInstall) {
+      const spinner = ora('Installing dependencies...').start()
+      await execa(pkgManager, ['install'], { cwd: projectDir })
+      spinner.succeed('...done!')
+      hasPlatformaticInstalled = true
+    }
+  }
+
+  if (!hasPlatformaticInstalled) {
+    try {
+      const npmLs = JSON.parse(await execa('npm', ['ls', '--json']))
+      hasPlatformaticInstalled = !!npmLs.dependencies.platformatic
+    } catch {
+      // Ignore all errors, this can fail
+    }
+  }
 
-  if (runPackageManagerInstall) {
-    const spinner = ora('Installing dependencies...').start()
-    await execa(pkgManager, ['install'], { cwd: projectDir })
-    spinner.succeed('...done!')
+  if (!hasPlatformaticInstalled) {
+    const exe = await which('platformatic', { nothrow: true })
+    hasPlatformaticInstalled = !!exe
   }
 
-  if (runPackageManagerInstall) {
+  if (hasPlatformaticInstalled) {
     // We applied package manager install, so we can:
     // - run the migrations
     // - generate types
@@ -166,8 +184,11 @@ const createPlatformaticDB = async (_args) => {
       }
     }
   }
-  await askDynamicWorkspaceCreateGHAction(logger, env, 'db', useTypescript, projectDir)
-  await askStaticWorkspaceGHAction(logger, env, 'db', useTypescript, projectDir)
+
+  if (!opts.skipGitHubActions) {
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'db', useTypescript, projectDir)
+    await askStaticWorkspaceGHAction(logger, env, 'db', useTypescript, projectDir)
+  }
 }
 
 export default createPlatformaticDB

package/src/ghaction.mjs

@@ -1,8 +1,7 @@
-import mkdirp from 'mkdirp'
 import { join } from 'path'
 import inquirer from 'inquirer'
 import { isFileAccessible } from './utils.mjs'
-import { writeFile } from 'fs/promises'
+import { writeFile, mkdir } from 'fs/promises'
 
 export const dynamicWorkspaceGHTemplate = (env, config, buildTS = false) => {
   const envAsStr = Object.keys(env).reduce((acc, key) => {
@@ -90,7 +89,7 @@ export const createDynamicWorkspaceGHAction = async (logger, env, config, projec
   const ghActionFilePath = join(projectDir, '.github', 'workflows', ghActionFileName)
   const isGithubActionExists = await isFileAccessible(ghActionFilePath)
   if (!isGithubActionExists) {
-    await mkdirp(join(projectDir, '.github', 'workflows'))
+    await mkdir(join(projectDir, '.github', 'workflows'), { recursive: true })
     await writeFile(ghActionFilePath, dynamicWorkspaceGHTemplate(env, config, buildTS))
     logger.info('Github action successfully created, please add PLATFORMATIC_DYNAMIC_WORKSPACE_ID and PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY as repository secrets.')
     const isGitDir = await isFileAccessible('.git', projectDir)
@@ -125,7 +124,7 @@ export const createStaticWorkspaceGHAction = async (logger, env, config, project
   const ghActionFilePath = join(projectDir, '.github', 'workflows', ghActionFileName)
   const isGithubActionExists = await isFileAccessible(ghActionFilePath)
   if (!isGithubActionExists) {
-    await mkdirp(join(projectDir, '.github', 'workflows'))
+    await mkdir(join(projectDir, '.github', 'workflows'), { recursive: true })
     await writeFile(ghActionFilePath, staticWorkspaceGHTemplate(env, config, buildTS))
     logger.info('Github action successfully created, please add PLATFORMATIC_STATIC_WORKSPACE_ID and PLATFORMATIC_STATIC_WORKSPACE_API_KEY as repository secret.')
     const isGitDir = await isFileAccessible('.git', projectDir)

package/src/index.mjs

@@ -2,10 +2,45 @@ import { say } from './say.mjs'
 import helpMe from 'help-me'
 import { join } from 'desm'
 import inquirer from 'inquirer'
+import { readdir, readFile } from 'fs/promises'
 import createPlatformaticDB from './db/create-db-cli.mjs'
 import createPlatformaticService from './service/create-service-cli.mjs'
+import createPlatformaticComposer from './composer/create-composer-cli.mjs'
+import { createPlatformaticRuntime, createRuntimeService } from './runtime/create-runtime-cli.mjs'
 import commist from 'commist'
-import { getUsername, getVersion, minimumSupportedNodeVersions, isCurrentVersionSupported } from './utils.mjs'
+import { getUsername, getVersion, minimumSupportedNodeVersions, isCurrentVersionSupported, findRuntimeConfigFile } from './utils.mjs'
+
+export async function chooseKind (argv, opts = {}) {
+  const skip = opts.skip
+  const choices = [
+    { name: 'DB', value: 'db' },
+    { name: 'Service', value: 'service' },
+    { name: 'Composer', value: 'composer' },
+    { name: 'Runtime', value: 'runtime' }
+  ].filter((choice) => !skip || choice.value !== skip)
+
+  const options = await inquirer.prompt({
+    type: 'list',
+    name: 'type',
+    message: 'Which kind of project do you want to create?',
+    choices
+  })
+
+  switch (options.type) {
+    case 'db':
+      await createPlatformaticDB(argv, opts)
+      break
+    case 'service':
+      await createPlatformaticService(argv, opts)
+      break
+    case 'composer':
+      await createPlatformaticComposer(argv, opts)
+      break
+    case 'runtime':
+      await createPlatformaticRuntime(argv, opts)
+      break
+  }
+}
 
 const createPlatformatic = async (argv) => {
   const help = helpMe({
@@ -20,6 +55,8 @@ const createPlatformatic = async (argv) => {
   program.register('service help', help.toStdout.bind(null, ['service']))
   program.register('db', createPlatformaticDB)
   program.register('service', createPlatformaticService)
+  program.register('composer', createPlatformaticComposer)
+  program.register('runtime', createPlatformaticRuntime)
 
   const result = program.parse(argv)
 
@@ -28,7 +65,6 @@ const createPlatformatic = async (argv) => {
     const version = await getVersion()
     const greeting = username ? `Hello, ${username}` : 'Hello,'
     await say(`${greeting} welcome to ${version ? `Platformatic ${version}!` : 'Platformatic!'}`)
-    await say('Let\'s start by creating a new project.')
 
     const currentVersion = process.versions.node
     const supported = isCurrentVersionSupported(currentVersion)
@@ -38,18 +74,26 @@ const createPlatformatic = async (argv) => {
       await say(`Please use one of the following Node.js versions >= ${supportedVersions}.`)
     }
 
-    const options = await inquirer.prompt({
-      type: 'list',
-      name: 'type',
-      message: 'Which kind of project do you want to create?',
-      default: 'db',
-      choices: [{ name: 'DB', value: 'db' }, { name: 'Service', value: 'service' }]
-    })
-
-    if (options.type === 'db') {
-      await createPlatformaticDB(argv)
-    } else if (options.type === 'service') {
-      await createPlatformaticService(argv)
+    const runtimeConfig = await findRuntimeConfigFile(process.cwd())
+    if (runtimeConfig) {
+      await say(`Found a ${runtimeConfig} file in the current directory.`)
+      const config = JSON.parse(await readFile(runtimeConfig, 'utf8'))
+      if (config.autoload?.path) {
+        const servicesDir = config.autoload.path
+        const names = []
+        for (const entry of await readdir(servicesDir)) {
+          names.push(entry)
+        }
+        if (!await createRuntimeService({ servicesDir, names })) {
+          process.exit(1)
+        }
+      } else {
+        await say('The current project does not have a services directory.')
+        process.exit(1)
+      }
+    } else {
+      await say('Let\'s start by creating a new project.')
+      await chooseKind(argv)
     }
 
     await say('\nAll done! Please open the project directory and check the README.')

package/src/runtime/README.md

@@ -0,0 +1,32 @@
+# Platformatic Runtime API
+
+This is a generated [Platformatic Runtime](https://oss.platformatic.dev/docs/reference/runtime/introduction) 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
+
+## 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/src/runtime/create-runtime-cli.mjs

@@ -0,0 +1,155 @@
+import { getVersion, getDependencyVersion, isFileAccessible } from '../utils.mjs'
+import { createPackageJson } from '../create-package-json.mjs'
+import { createGitignore } from '../create-gitignore.mjs'
+import { getPkgManager } from '../get-pkg-manager.mjs'
+import { join } from 'path'
+import inquirer from 'inquirer'
+import { readFile, writeFile, mkdir } from 'fs/promises'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { execa } from 'execa'
+import ora from 'ora'
+import createRuntime from './create-runtime.mjs'
+import askDir from '../ask-dir.mjs'
+import { askDynamicWorkspaceCreateGHAction, askStaticWorkspaceGHAction } from '../ghaction.mjs'
+import { getRunPackageManagerInstall } from '../cli-options.mjs'
+import generateName from 'boring-name-generator'
+import { chooseKind } from '../index.mjs'
+
+export const createReadme = async (logger, dir = '.') => {
+  const readmeFileName = join(dir, 'README.md')
+  let isReadmeExists = await isFileAccessible(readmeFileName)
+  if (isReadmeExists) {
+    logger.debug(`${readmeFileName} found, asking to overwrite it.`)
+    const { shouldReplace } = await inquirer.prompt([{
+      type: 'list',
+      name: 'shouldReplace',
+      message: 'Do you want to overwrite the existing README.md?',
+      default: true,
+      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
+    }])
+    isReadmeExists = !shouldReplace
+  }
+
+  if (isReadmeExists) {
+    logger.debug(`${readmeFileName} found, skipping creation of README.md file.`)
+    return
+  }
+
+  const readmeFile = new URL('README.md', import.meta.url)
+  const readme = await readFile(readmeFile, 'utf-8')
+  await writeFile(readmeFileName, readme)
+  logger.debug(`${readmeFileName} successfully created.`)
+}
+
+export async function createPlatformaticRuntime (_args) {
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+
+  const version = await getVersion()
+  const pkgManager = getPkgManager()
+
+  const projectDir = await askDir(logger, '.')
+  const servicesDir = await askDir(logger, 'services', 'Where would you like to load your services from?')
+
+  const { runPackageManagerInstall } = await inquirer.prompt([
+    getRunPackageManagerInstall(pkgManager)
+  ])
+
+  // Create the project directory
+  await mkdir(projectDir, { recursive: true })
+  await mkdir(servicesDir, { recursive: true })
+
+  const fastifyVersion = await getDependencyVersion('fastify')
+
+  // Create the package.json, notes that we don't have the option for TS (yet) so we don't generate
+  // the package.json with the TS build
+  await createPackageJson('runtime', version, fastifyVersion, logger, projectDir, false)
+  await createGitignore(logger, projectDir)
+  await createReadme(logger, projectDir)
+
+  if (runPackageManagerInstall) {
+    const spinner = ora('Installing dependencies...').start()
+    await execa(pkgManager, ['install'], { cwd: projectDir })
+    spinner.succeed('...done!')
+  }
+
+  logger.info('Let\'s create a first service!')
+
+  const names = []
+  while (true) {
+    if (!await createRuntimeService({ servicesDir, names, logger })) {
+      continue
+    }
+
+    const { shouldBreak } = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'shouldBreak',
+        message: 'Do you want to create another service?',
+        default: false,
+        choices: [{ name: 'yes', value: false }, { name: 'no', value: true }]
+      }
+    ])
+
+    if (shouldBreak) {
+      break
+    }
+  }
+
+  let entrypoint = ''
+
+  if (names.length > 1) {
+    const results = await inquirer.prompt([
+      {
+        type: 'list',
+        name: 'entrypoint',
+        message: 'Which service should be exposed?',
+        choices: names.map(name => ({ name, value: name }))
+      }
+    ])
+    entrypoint = results.entrypoint
+  } else {
+    entrypoint = names[0]
+  }
+
+  const env = await createRuntime(logger, projectDir, version, servicesDir, entrypoint)
+
+  await askDynamicWorkspaceCreateGHAction(logger, env, 'service', false, projectDir)
+  await askStaticWorkspaceGHAction(logger, env, 'service', false, projectDir)
+}
+
+export async function createRuntimeService ({ servicesDir, names, logger }) {
+  logger ||= pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+  const { name } = await inquirer.prompt({
+    type: 'input',
+    name: 'name',
+    message: 'What is the name of the service?',
+    default: generateName().dashed
+  })
+
+  if (names.includes(name)) {
+    logger.warn('This name is already used, please choose another one.')
+    return false
+  }
+  names.push(name)
+
+  const serviceDir = join(servicesDir, name)
+
+  await chooseKind([], {
+    skip: 'runtime',
+    dir: serviceDir,
+    logger,
+    skipGitHubActions: true,
+    skipPackageJson: true,
+    skipGitignore: true,
+    port: '0'
+  })
+
+  return true
+}

package/src/runtime/create-runtime.mjs

@@ -0,0 +1,40 @@
+import { readFile, writeFile } from 'fs/promises'
+import { findRuntimeConfigFile } from '../utils.mjs'
+import { join, relative, isAbsolute } from 'path'
+import * as desm from 'desm'
+
+function generateConfig (version, path, entrypoint) {
+  const config = {
+    $schema: `https://platformatic.dev/schemas/v${version}/runtime`,
+    entrypoint,
+    allowCycles: false,
+    hotReload: true,
+    autoload: {
+      path,
+      exclude: ['docs']
+    }
+  }
+
+  return config
+}
+
+async function createRuntime (logger, currentDir = process.cwd(), version, servicesDir, entrypoint) {
+  if (!version) {
+    const pkg = await readFile(desm.join(import.meta.url, '..', '..', 'package.json'))
+    version = JSON.parse(pkg).version
+  }
+  const accessibleConfigFilename = await findRuntimeConfigFile(currentDir)
+
+  if (accessibleConfigFilename === undefined) {
+    const path = isAbsolute(servicesDir) ? relative(currentDir, servicesDir) : servicesDir
+    const config = generateConfig(version, path, entrypoint)
+    await writeFile(join(currentDir, 'platformatic.runtime.json'), JSON.stringify(config, null, 2))
+    logger.info('Configuration file platformatic.runtime.json successfully created.')
+  } else {
+    logger.info(`Configuration file ${accessibleConfigFilename} found, skipping creation of configuration file.`)
+  }
+
+  return {}
+}
+
+export default createRuntime

package/src/service/create-service-cli.mjs

@@ -1,4 +1,3 @@
-
 import { getVersion, getDependencyVersion, isFileAccessible } from '../utils.mjs'
 import { createPackageJson } from '../create-package-json.mjs'
 import { createGitignore } from '../create-gitignore.mjs'
@@ -6,16 +5,15 @@ import { getPkgManager } from '../get-pkg-manager.mjs'
 import parseArgs from 'minimist'
 import { join } from 'path'
 import inquirer from 'inquirer'
-import { readFile, writeFile } from 'fs/promises'
+import { readFile, writeFile, mkdir } from 'fs/promises'
 import pino from 'pino'
 import pretty from 'pino-pretty'
 import { execa } from 'execa'
 import ora from 'ora'
 import createService from './create-service.mjs'
-import askProjectDir from '../ask-project-dir.mjs'
+import askDir from '../ask-dir.mjs'
 import { askDynamicWorkspaceCreateGHAction, askStaticWorkspaceGHAction } from '../ghaction.mjs'
-import { getRunPackageManagerInstall, getUseTypescript } from '../cli-options.mjs'
-import mkdirp from 'mkdirp'
+import { getRunPackageManagerInstall, getUseTypescript, getPort } from '../cli-options.mjs'
 
 export const createReadme = async (logger, dir = '.') => {
   const readmeFileName = join(dir, 'README.md')
@@ -43,16 +41,15 @@ export const createReadme = async (logger, dir = '.') => {
   logger.debug(`${readmeFileName} successfully created.`)
 }
 
-const createPlatformaticService = async (_args) => {
-  const logger = pino(pretty({
+const createPlatformaticService = async (_args, opts = {}) => {
+  const logger = opts.logger || pino(pretty({
     translateTime: 'SYS:HH:MM:ss',
     ignore: 'hostname,pid'
   }))
 
   const args = parseArgs(_args, {
     default: {
-      hostname: '127.0.0.1',
-      port: 3042
+      hostname: '127.0.0.1'
     },
     alias: {
       h: 'hostname',
@@ -63,19 +60,22 @@ const createPlatformaticService = async (_args) => {
   const version = await getVersion()
   const pkgManager = getPkgManager()
 
-  const projectDir = await askProjectDir(logger, '.')
+  const projectDir = opts.dir || await askDir(logger, '.')
+
+  const toAsk = [getUseTypescript(args.typescript), getPort(args.port)]
+
+  if (!opts.skipPackageJson) {
+    toAsk.unshift(getRunPackageManagerInstall(pkgManager))
+  }
 
-  const { runPackageManagerInstall, useTypescript } = await inquirer.prompt([
-    getRunPackageManagerInstall(pkgManager),
-    getUseTypescript(args.typescript)
-  ])
+  const { runPackageManagerInstall, useTypescript, port } = await inquirer.prompt(toAsk)
 
   // Create the project directory
-  await mkdirp(projectDir)
+  await mkdir(projectDir, { recursive: true })
 
   const params = {
     hostname: args.hostname,
-    port: args.port,
+    port,
     typescript: useTypescript
   }
 
@@ -83,10 +83,14 @@ const createPlatformaticService = async (_args) => {
 
   const fastifyVersion = await getDependencyVersion('fastify')
 
-  // Create the package.json, notes that we don't have the option for TS (yet) so we don't generate
-  // the package.json with the TS build
-  await createPackageJson('service', version, fastifyVersion, logger, projectDir, false)
-  await createGitignore(logger, projectDir)
+  if (!opts.skipPackageJson) {
+    // Create the package.json, notes that we don't have the option for TS (yet) so we don't generate
+    // the package.json with the TS build
+    await createPackageJson('service', version, fastifyVersion, logger, projectDir, false)
+  }
+  if (!opts.skipGitignore) {
+    await createGitignore(logger, projectDir)
+  }
   await createReadme(logger, projectDir)
 
   if (runPackageManagerInstall) {
@@ -95,8 +99,10 @@ const createPlatformaticService = async (_args) => {
     spinner.succeed('...done!')
   }
 
-  await askDynamicWorkspaceCreateGHAction(logger, env, 'service', useTypescript, projectDir)
-  await askStaticWorkspaceGHAction(logger, env, 'service', useTypescript, projectDir)
+  if (!opts.skipGitHubActions) {
+    await askDynamicWorkspaceCreateGHAction(logger, env, 'service', useTypescript, projectDir)
+    await askStaticWorkspaceGHAction(logger, env, 'service', useTypescript, projectDir)
+  }
 }
 
 export default createPlatformaticService

package/src/service/create-service.mjs

@@ -22,6 +22,9 @@ function generateConfig (version, typescript) {
         level: '{PLT_SERVER_LOGGER_LEVEL}'
       }
     },
+    service: {
+      openapi: true
+    },
     plugins
   }
 

package/src/utils.mjs

@@ -70,6 +70,8 @@ export const validatePath = async projectPath => {
 
 export const findDBConfigFile = async (directory) => (ConfigManager.findConfigFile(directory, 'db'))
 export const findServiceConfigFile = async (directory) => (ConfigManager.findConfigFile(directory, 'service'))
+export const findComposerConfigFile = async (directory) => (ConfigManager.findConfigFile(directory, 'composer'))
+export const findRuntimeConfigFile = async (directory) => (ConfigManager.findConfigFile(directory, 'runtime'))
 
 export const getDependencyVersion = async (dependencyName) => {
   const require = createRequire(import.meta.url)

package/test/cli-options.test.mjs

@@ -1,5 +1,5 @@
 import { test } from 'tap'
-import { getRunPackageManagerInstall, getUseTypescript } from '../src/cli-options.mjs'
+import { getRunPackageManagerInstall, getUseTypescript, getPort } from '../src/cli-options.mjs'
 
 test('getRunPackageManagerInstall', async ({ same }) => {
   same(
@@ -27,3 +27,45 @@ test('getUseTypescript', async ({ same }) => {
     }
   )
 })
+
+test('getPort', async ({ same }) => {
+  same(
+    getPort(undefined),
+    {
+      type: 'input',
+      name: 'port',
+      message: 'What port do you want to use?',
+      default: 3042
+    }
+  )
+
+  same(
+    getPort(undefined),
+    {
+      type: 'input',
+      name: 'port',
+      message: 'What port do you want to use?',
+      default: 3043
+    }
+  )
+
+  same(
+    getPort(1234),
+    {
+      type: 'input',
+      name: 'port',
+      message: 'What port do you want to use?',
+      default: 1234
+    }
+  )
+
+  same(
+    getPort(undefined),
+    {
+      type: 'input',
+      name: 'port',
+      message: 'What port do you want to use?',
+      default: 3044
+    }
+  )
+})

package/test/composer/create-composer.test.mjs

@@ -0,0 +1,75 @@
+import createComposer from '../../src/composer/create-composer.mjs'
+import { test, beforeEach, afterEach } from 'tap'
+import { tmpdir } from 'os'
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+import dotenv from 'dotenv'
+
+const base = tmpdir()
+let tmpDir
+let log = []
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(base, 'test-create-platformatic-'))
+})
+
+afterEach(() => {
+  log = []
+  rmSync(tmpDir, { recursive: true, force: true })
+  process.env = {}
+})
+
+const fakeLogger = {
+  debug: msg => log.push(msg),
+  info: msg => log.push(msg)
+}
+
+test('creates composer', async ({ equal, same, ok }) => {
+  const params = {
+    hostname: 'myhost',
+    port: 6666,
+    typescript: false
+  }
+
+  await createComposer(params, fakeLogger, tmpDir)
+
+  const pathToComposerConfigFile = join(tmpDir, 'platformatic.composer.json')
+  const composerConfigFile = readFileSync(pathToComposerConfigFile, 'utf8')
+  const composerConfig = JSON.parse(composerConfigFile)
+  const { server, composer } = composerConfig
+
+  equal(server.hostname, '{PLT_SERVER_HOSTNAME}')
+  equal(server.port, '{PORT}')
+
+  const pathToDbEnvFile = join(tmpDir, '.env')
+  dotenv.config({ path: pathToDbEnvFile })
+  equal(process.env.PLT_SERVER_HOSTNAME, 'myhost')
+  equal(process.env.PORT, '6666')
+  process.env = {}
+
+  const pathToDbEnvSampleFile = join(tmpDir, '.env.sample')
+  dotenv.config({ path: pathToDbEnvSampleFile })
+  equal(process.env.PLT_SERVER_HOSTNAME, 'myhost')
+  equal(process.env.PORT, '6666')
+
+  same(composer, {
+    services: [{
+      id: 'example',
+      origin: '{PLT_EXAMPLE_ORIGIN}',
+      openapi: {
+        url: '/documentation/json'
+      }
+    }],
+    refreshTimeout: 1000
+  })
+})
+
+test('creates project with configuration already present', async ({ ok }) => {
+  const pathToComposerConfigFileOld = join(tmpDir, 'platformatic.composer.json')
+  writeFileSync(pathToComposerConfigFileOld, JSON.stringify({ test: 'test' }))
+  const params = {
+    hostname: 'myhost',
+    port: 6666
+  }
+  await createComposer(params, fakeLogger, tmpDir)
+  ok(log.includes('Configuration file platformatic.composer.json found, skipping creation of configuration file.'))
+})

package/test/ghaction-dynamic.test.mjs

@@ -1,8 +1,7 @@
 'use strict'
 
 import { test, beforeEach, afterEach } from 'tap'
-import { mkdtemp, rmdir, writeFile, readFile } from 'fs/promises'
-import mkdirp from 'mkdirp'
+import { mkdtemp, rmdir, writeFile, readFile, mkdir } from 'fs/promises'
 import { join } from 'path'
 import { tmpdir } from 'os'
 import { isFileAccessible } from '../src/utils.mjs'
@@ -70,7 +69,7 @@ test('creates gh action with TS build step', async ({ end, equal }) => {
 })
 
 test('do not create gitignore file because already present', async ({ end, equal }) => {
-  await mkdirp(join(tmpDir, '.github', 'workflows'))
+  await mkdir(join(tmpDir, '.github', 'workflows'), { recursive: true })
   const ghaction = join(tmpDir, '.github', 'workflows', 'platformatic-dynamic-workspace-deploy.yml')
   await writeFile(ghaction, 'TEST')
   await createDynamicWorkspaceGHAction(fakeLogger, env, 'db', tmpDir)
@@ -86,7 +85,7 @@ test('creates gh action with a warn if a .git folder is not present', async ({ e
 })
 
 test('creates gh action without a warn if a .git folder is present', async ({ end, equal }) => {
-  await mkdirp(join(tmpDir, '.git'))
+  await mkdir(join(tmpDir, '.git'), { recursive: true })
   await createDynamicWorkspaceGHAction(fakeLogger, env, 'db', tmpDir)
   equal(log[0], 'Github action successfully created, please add PLATFORMATIC_DYNAMIC_WORKSPACE_ID and PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY as repository secrets.')
   const accessible = await isFileAccessible(join(tmpDir, '.github/workflows/platformatic-dynamic-workspace-deploy.yml'))

package/test/ghaction-static.test.mjs

@@ -1,8 +1,7 @@
 'use strict'
 
 import { test, beforeEach, afterEach } from 'tap'
-import { mkdtemp, rmdir, writeFile, readFile } from 'fs/promises'
-import mkdirp from 'mkdirp'
+import { mkdtemp, rmdir, writeFile, readFile, mkdir } from 'fs/promises'
 import { join } from 'path'
 import { tmpdir } from 'os'
 import { isFileAccessible } from '../src/utils.mjs'
@@ -68,7 +67,7 @@ test('creates gh action with TS build step', async ({ end, equal }) => {
 })
 
 test('do not create gitignore file because already present', async ({ end, equal }) => {
-  await mkdirp(join(tmpDir, '.github', 'workflows'))
+  await mkdir(join(tmpDir, '.github', 'workflows'), { recursive: true })
   const ghaction = join(tmpDir, '.github', 'workflows', 'platformatic-static-workspace-deploy.yml')
   await writeFile(ghaction, 'TEST')
   await createStaticWorkspaceGHAction(fakeLogger, env, 'db', tmpDir)
@@ -84,7 +83,7 @@ test('creates gh action with a warn if a .git folder is not present', async ({ e
 })
 
 test('creates gh action without a warn if a .git folder is present', async ({ end, equal }) => {
-  await mkdirp(join(tmpDir, '.git'))
+  await mkdir(join(tmpDir, '.git'), { recursive: true })
   await createStaticWorkspaceGHAction(fakeLogger, env, 'db', tmpDir)
   equal(log[0], 'Github action successfully created, please add PLATFORMATIC_STATIC_WORKSPACE_ID and PLATFORMATIC_STATIC_WORKSPACE_API_KEY as repository secret.')
   const accessible = await isFileAccessible(join(tmpDir, '.github/workflows/platformatic-static-workspace-deploy.yml'))

package/test/runtime/create-runtime.test.mjs

@@ -0,0 +1,70 @@
+import createRuntime from '../../src/runtime/create-runtime.mjs'
+import { test, beforeEach, afterEach } from 'tap'
+import { tmpdir } from 'os'
+import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'fs'
+import { join } from 'path'
+
+const base = tmpdir()
+let tmpDir
+let log = []
+beforeEach(() => {
+  tmpDir = mkdtempSync(join(base, 'test-create-platformatic-'))
+})
+
+afterEach(() => {
+  log = []
+  rmSync(tmpDir, { recursive: true, force: true })
+  process.env = {}
+})
+
+const fakeLogger = {
+  debug: msg => log.push(msg),
+  info: msg => log.push(msg)
+}
+
+test('creates runtime', async ({ equal, same, ok }) => {
+  await createRuntime(fakeLogger, tmpDir, undefined, 'services', 'foobar')
+
+  const pathToRuntimeConfigFile = join(tmpDir, 'platformatic.runtime.json')
+  const runtimeConfigFile = readFileSync(pathToRuntimeConfigFile, 'utf8')
+  const runtimeConfig = JSON.parse(runtimeConfigFile)
+
+  delete runtimeConfig.$schema
+
+  same(runtimeConfig, {
+    entrypoint: 'foobar',
+    allowCycles: false,
+    hotReload: true,
+    autoload: {
+      path: 'services',
+      exclude: ['docs']
+    }
+  })
+})
+
+test('with a full path for autoload', async ({ equal, same, ok }) => {
+  await createRuntime(fakeLogger, tmpDir, undefined, join(tmpDir, 'services'), 'foobar')
+
+  const pathToRuntimeConfigFile = join(tmpDir, 'platformatic.runtime.json')
+  const runtimeConfigFile = readFileSync(pathToRuntimeConfigFile, 'utf8')
+  const runtimeConfig = JSON.parse(runtimeConfigFile)
+
+  delete runtimeConfig.$schema
+
+  same(runtimeConfig, {
+    entrypoint: 'foobar',
+    allowCycles: false,
+    hotReload: true,
+    autoload: {
+      path: 'services',
+      exclude: ['docs']
+    }
+  })
+})
+
+test('creates project with configuration already present', async ({ ok }) => {
+  const pathToRuntimeConfigFileOld = join(tmpDir, 'platformatic.runtime.json')
+  writeFileSync(pathToRuntimeConfigFileOld, JSON.stringify({ test: 'test' }))
+  await createRuntime(fakeLogger, tmpDir, 'foobar')
+  ok(log.includes('Configuration file platformatic.runtime.json found, skipping creation of configuration file.'))
+})

package/test/utils.test.mjs

@@ -1,5 +1,5 @@
 import { test } from 'tap'
-import { randomBetween, sleep, validatePath, getDependencyVersion, findDBConfigFile, findServiceConfigFile, isFileAccessible, isCurrentVersionSupported, minimumSupportedNodeVersions } from '../src/utils.mjs'
+import { randomBetween, sleep, validatePath, getDependencyVersion, findDBConfigFile, findServiceConfigFile, isFileAccessible, isCurrentVersionSupported, minimumSupportedNodeVersions, findRuntimeConfigFile, findComposerConfigFile } from '../src/utils.mjs'
 import { mkdtempSync, rmSync, writeFileSync } from 'fs'
 import { tmpdir, platform } from 'os'
 import { join } from 'path'
@@ -158,6 +158,28 @@ test('findServiceConfigFile', async ({ end, equal, mock }) => {
   rmSync(tmpDir2, { recursive: true, force: true })
 })
 
+test('findComposerConfigFile', async ({ end, equal, mock }) => {
+  const tmpDir1 = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
+  const tmpDir2 = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
+  const config = join(tmpDir1, 'platformatic.composer.yml')
+  writeFileSync(config, 'TEST')
+  equal(await findComposerConfigFile(tmpDir1), 'platformatic.composer.yml')
+  equal(await findComposerConfigFile(tmpDir2), undefined)
+  rmSync(tmpDir1, { recursive: true, force: true })
+  rmSync(tmpDir2, { recursive: true, force: true })
+})
+
+test('findRuntimeConfigFile', async ({ end, equal, mock }) => {
+  const tmpDir1 = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
+  const tmpDir2 = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
+  const config = join(tmpDir1, 'platformatic.runtime.yml')
+  writeFileSync(config, 'TEST')
+  equal(await findRuntimeConfigFile(tmpDir1), 'platformatic.runtime.yml')
+  equal(await findRuntimeConfigFile(tmpDir2), undefined)
+  rmSync(tmpDir1, { recursive: true, force: true })
+  rmSync(tmpDir2, { recursive: true, force: true })
+})
+
 test('isFileAccessible', async ({ end, equal, mock }) => {
   const tmpDir1 = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
   const config = join(tmpDir1, 'platformatic.db.yml')