create-platformatic 0.24.0 → 0.26.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "0.24.0",
+  "version": "0.26.0",
   "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",
@@ -22,30 +23,30 @@
     "execa": "^7.1.1",
     "fastify": "^4.17.0",
     "help-me": "^4.2.0",
-    "inquirer": "^9.2.0",
+    "inquirer": "^9.2.6",
     "log-update": "^5.0.1",
     "minimist": "^1.2.8",
-    "mkdirp": "^2.1.6",
-    "ora": "^6.3.0",
-    "pino": "^8.12.0",
+    "ora": "^6.3.1",
+    "pino": "^8.14.1",
     "pino-pretty": "^10.0.0",
     "pupa": "^3.1.0",
-    "semver": "^7.5.0",
-    "undici": "^5.22.0",
-    "@platformatic/config": "0.24.0"
+    "semver": "^7.5.1",
+    "undici": "^5.22.1",
+    "which": "^3.0.1",
+    "@platformatic/config": "0.26.0"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
     "c8": "^7.13.0",
     "cross-env": "^7.0.3",
     "dotenv": "^16.0.3",
-    "esmock": "^2.2.1",
+    "esmock": "^2.2.3",
     "snazzy": "^9.0.0",
     "standard": "^17.0.0",
     "tap": "^16.3.4",
     "yaml": "^2.2.2",
-    "@platformatic/db": "0.24.0",
-    "@platformatic/service": "0.24.0"
+    "@platformatic/db": "0.26.0",
+    "@platformatic/service": "0.26.0"
   },
   "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/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,10 +1,9 @@
-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 = (workspaceId, env, config, buildTS = false) => {
+export const dynamicWorkspaceGHTemplate = (env, config, buildTS = false) => {
   const envAsStr = Object.keys(env).reduce((acc, key) => {
     acc += `          ${key}: ${env[key]} \n`
     return acc
@@ -36,7 +35,7 @@ jobs:
         uses: platformatic/onestep@latest
         with:
           github_token: \${{ secrets.GITHUB_TOKEN }}
-          platformatic_workspace_id: ${workspaceId}
+          platformatic_workspace_id: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_ID }}
           platformatic_workspace_key: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY }}
           platformatic_config_path: ${config}
         env:
@@ -44,7 +43,7 @@ ${envAsStr}
 `
 }
 
-export const staticWorkspaceGHTemplate = (workspaceId, env, config, buildTS = false) => {
+export const staticWorkspaceGHTemplate = (env, config, buildTS = false) => {
   const envAsStr = Object.keys(env).reduce((acc, key) => {
     acc += `          ${key}: ${env[key]} \n`
     return acc
@@ -77,7 +76,7 @@ jobs:
         uses: platformatic/onestep@latest
         with:
           github_token: \${{ secrets.GITHUB_TOKEN }}
-          platformatic_workspace_id: ${workspaceId}
+          platformatic_workspace_id: \${{ secrets.PLATFORMATIC_STATIC_WORKSPACE_ID }}
           platformatic_workspace_key: \${{ secrets.PLATFORMATIC_STATIC_WORKSPACE_API_KEY }}
           platformatic_config_path: ${config}
         env:
@@ -85,19 +84,14 @@ ${envAsStr}
 `
 }
 
-export const createDynamicWorkspaceGHAction = async (logger, workspaceId, env, config, projectDir, buildTS) => {
+export const createDynamicWorkspaceGHAction = async (logger, env, config, projectDir, buildTS) => {
   const ghActionFileName = 'platformatic-dynamic-workspace-deploy.yml'
   const ghActionFilePath = join(projectDir, '.github', 'workflows', ghActionFileName)
   const isGithubActionExists = await isFileAccessible(ghActionFilePath)
   if (!isGithubActionExists) {
-    if (!workspaceId) {
-      logger.info('No workspace ID provided, skipping creation of github action file.')
-      return
-    }
-
-    await mkdirp(join(projectDir, '.github', 'workflows'))
-    await writeFile(ghActionFilePath, dynamicWorkspaceGHTemplate(workspaceId, env, config, buildTS))
-    logger.info('Github action successfully created, please add PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY as repository secret.')
+    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)
     if (!isGitDir) {
       logger.warn('No git repository found. The Github action won\'t be triggered.')
@@ -119,32 +113,20 @@ export const askDynamicWorkspaceCreateGHAction = async (logger, env, type, build
     }
   ])
   if (githubAction) {
-    const { workspaceId } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'workspaceId',
-        message: 'Please enter the workspace ID:'
-      }
-    ])
     const config = `./platformatic.${type}.json`
-    await createDynamicWorkspaceGHAction(logger, workspaceId, env, config, projectDir, buildTS)
+    await createDynamicWorkspaceGHAction(logger, env, config, projectDir, buildTS)
   }
 /* c8 ignore next */
 }
 
-export const createStaticWorkspaceGHAction = async (logger, workspaceId, env, config, projectDir, buildTS) => {
+export const createStaticWorkspaceGHAction = async (logger, env, config, projectDir, buildTS) => {
   const ghActionFileName = 'platformatic-static-workspace-deploy.yml'
   const ghActionFilePath = join(projectDir, '.github', 'workflows', ghActionFileName)
   const isGithubActionExists = await isFileAccessible(ghActionFilePath)
   if (!isGithubActionExists) {
-    if (!workspaceId) {
-      logger.info('No workspace ID provided, skipping creation of github action file.')
-      return
-    }
-
-    await mkdirp(join(projectDir, '.github', 'workflows'))
-    await writeFile(ghActionFilePath, staticWorkspaceGHTemplate(workspaceId, env, config, buildTS))
-    logger.info('Github action successfully created, please add PLATFORMATIC_STATIC_WORKSPACE_API_KEY as repository secret.')
+    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)
     if (!isGitDir) {
       logger.warn('No git repository found. The Github action won\'t be triggered.')
@@ -166,15 +148,8 @@ export const askStaticWorkspaceGHAction = async (logger, env, type, buildTS, pro
     }
   ])
   if (githubAction) {
-    const { workspaceId } = await inquirer.prompt([
-      {
-        type: 'input',
-        name: 'workspaceId',
-        message: 'Please enter the workspace ID:'
-      }
-    ])
     const config = `./platformatic.${type}.json`
-    await createStaticWorkspaceGHAction(logger, workspaceId, env, config, projectDir, buildTS)
+    await createStaticWorkspaceGHAction(logger, env, config, projectDir, buildTS)
   }
 /* c8 ignore next */
 }

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.')