create-platformatic 3.0.0-alpha.1 → 3.0.0-alpha.4

package/README.md

@@ -1,4 +1,4 @@
-# create-platformatic
+# create-wattpm
 
 Platformatic Creator
 

package/bin/cli.js

@@ -0,0 +1,23 @@
+#!/usr/bin/env node
+
+import { checkNodeVersionForServices } from '@platformatic/foundation'
+import { createPlatformatic } from 'create-wattpm'
+import parseArgs from 'minimist'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+checkNodeVersionForServices()
+
+const _args = process.argv.slice(2)
+const args = parseArgs(_args, {
+  alias: {
+    v: 'version'
+  }
+})
+
+if (args.version) {
+  console.log('v' + JSON.parse(await readFile(join(import.meta.dirname, 'package.json'), 'utf8')).version)
+  process.exit(0)
+}
+
+await createPlatformatic(_args)

package/eslint.config.js

@@ -1,3 +1,3 @@
-'use strict'
+import neostandard from 'neostandard'
 
-module.exports = require('neostandard')({})
+export default neostandard()

package/package.json

@@ -1,60 +1,33 @@
 {
   "name": "create-platformatic",
-  "version": "3.0.0-alpha.1",
+  "version": "3.0.0-alpha.4",
   "description": "Create platformatic application interactive tool",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
-  "exports": {
-    ".": "./bin/create-platformatic.mjs"
-  },
   "bin": {
-    "create-platformatic": "./bin/create-platformatic.mjs"
+    "create-platformatic": "./bin/cli.js"
   },
+  "type": "module",
   "license": "Apache-2.0",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "dependencies": {
-    "columnify": "^1.6.0",
-    "commist": "^3.2.0",
-    "es-main": "^1.3.0",
-    "execa": "^9.0.0",
-    "help-me": "^5.0.0",
-    "inquirer": "^9.2.16",
-    "minimist": "^1.2.8",
-    "ora": "^6.3.1",
-    "pino": "^9.0.0",
-    "pino-pretty": "^13.0.0",
-    "resolve": "^1.22.8",
-    "semver": "^7.6.0",
-    "strip-ansi": "^7.1.0",
-    "undici": "^7.0.0",
-    "which": "^3.0.1",
-    "@platformatic/generators": "3.0.0-alpha.1",
-    "@platformatic/utils": "3.0.0-alpha.1"
+    "@platformatic/foundation": "3.0.0-alpha.4",
+    "create-wattpm": "3.0.0-alpha.4"
   },
   "devDependencies": {
-    "@types/node": "^22.5.0",
-    "ajv": "^8.12.0",
     "borp": "^0.20.0",
-    "c8": "^10.0.0",
-    "cross-env": "^7.0.3",
-    "dotenv": "^16.4.5",
     "eslint": "9",
-    "esmock": "^2.6.4",
-    "fastify": "^5.0.0",
-    "neostandard": "^0.12.0",
-    "typescript": "~5.8.0",
-    "yaml": "^2.4.1",
-    "@platformatic/composer": "3.0.0-alpha.1",
-    "@platformatic/db": "3.0.0-alpha.1",
-    "@platformatic/service": "3.0.0-alpha.1",
-    "@platformatic/runtime": "3.0.0-alpha.1"
+    "import-in-the-middle": "^1.14.2",
+    "neostandard": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=22.18.0"
   },
   "scripts": {
-    "test:cli": "borp --pattern \"test/cli/*test.mjs\" --timeout=1200000 --concurrency=1",
-    "test:unit": "pnpm run lint && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" borp --pattern \"test/unit/*test.mjs\" --timeout=1200000 --concurrency=1",
-    "test": "npm run test:unit && npm run test:cli",
-    "lint": "eslint"
+    "test": "pnpm run lint && borp --timeout 1200000 --concurrency 1",
+    "lint": "eslint",
+    "license": "license-checker --production --onlyAllow 'Apache-2.0;MIT;ISC;BSD-2-Clause;BSD-3-Clause;CC-BY-4.0;BlueOak-1.0.0'"
   }
 }

package/test/index.test.js

@@ -0,0 +1,15 @@
+import { execa } from 'execa'
+import { deepStrictEqual } from 'node:assert'
+import { resolve } from 'node:path'
+import { test } from 'node:test'
+import { pathToFileURL } from 'node:url'
+
+test('should be an alias for create-wattpm', async t => {
+  const { stdout } = await execa(process.argv[0], [
+    '--import',
+    pathToFileURL(resolve(import.meta.dirname, './loader.js')).toString(),
+    resolve(import.meta.dirname, '../bin/cli.js')
+  ])
+
+  deepStrictEqual(stdout.trim(), 'OK')
+})

package/test/loader.js

@@ -0,0 +1,13 @@
+import { Hook } from 'import-in-the-middle'
+import { register } from 'node:module'
+import { fileURLToPath } from 'node:url'
+
+register('import-in-the-middle/hook.mjs', import.meta.url)
+
+// The package name will not work as we are in a pnpm workspace
+// eslint-disable-next-line no-new
+new Hook([fileURLToPath(new URL('../../create-wattpm/lib/index.js', import.meta.url))], function (exported) {
+  exported.createPlatformatic = async function () {
+    console.log('OK')
+  }
+})

package/bin/create-platformatic.mjs

@@ -1,27 +0,0 @@
-#!/usr/bin/env node
-import { checkNodeVersionForServices } from '@platformatic/utils'
-import isMain from 'es-main'
-import { readFile } from 'fs/promises'
-import parseArgs from 'minimist'
-import { join } from 'node:path'
-import { createPlatformatic } from '../src/index.mjs'
-
-if (isMain(import.meta)) {
-  checkNodeVersionForServices()
-
-  const _args = process.argv.slice(2)
-  const args = parseArgs(_args, {
-    alias: {
-      v: 'version'
-    }
-  })
-
-  if (args.version) {
-    console.log('v' + JSON.parse(await readFile(join(import.meta.dirname, 'package.json'), 'utf8')).version)
-    process.exit(0)
-  }
-  await createPlatformatic(_args)
-}
-
-export * from '../src/index.mjs'
-export * from '../src/utils.mjs'

package/src/create-git-repository.mjs

@@ -1,108 +0,0 @@
-import { execa } from 'execa'
-
-export const GIT_FIRST_COMMIT_MESSAGE = 'Platformatic project started! 🚀'
-export const GIT_MAIN_BRANCH = 'main'
-
-/**
- * Creates a Git repository and performs the initial commit if it doesn't already exist.
- *
- * This function checks if Git is installed, initializes a Git repository in the specified
- * directory if it's not already a Git repository, and performs the initial commit.
- *
- * @param {import('pino.').BaseLogger} logger - The logger interface for logging messages.
- * @param {string} [dir='.'] - The target directory where the Git repository should be created.
- */
-export async function createGitRepository (logger, dir = '.') {
-  if (!await isGitInstalled()) {
-    logger.error('Git is not installed')
-    return
-  }
-
-  if (!await gitInit(logger, dir)) {
-    return
-  }
-
-  if (!await gitCommit(logger, dir)) {
-    return
-  }
-
-  logger.info('Git repository initialized.')
-}
-
-/**
- * Checks if Git is installed on the system.
- *
- * @async
- * @returns {Promise<boolean>} A Promise that resolves to true if Git is installed, false otherwise.
- */
-async function isGitInstalled () {
-  try {
-    await execa('git', ['--version'])
-    return true
-  } catch (err) {
-    return false
-  }
-}
-
-/**
- * Checks if a Git repository exists in the specified directory.
- *
- * @async
- * @param {string} dir - The directory to check for a Git repository.
- * @returns {Promise<boolean>} A Promise that resolves to true if a Git repository exists in the directory, false otherwise.
- */
-async function doesGitRepositoryExist (dir) {
-  try {
-    await execa('git', ['rev-parse', '--is-inside-work-tree'], { cwd: dir })
-    return true
-  } catch (e) {
-    return false
-  }
-}
-
-/**
- * Initializes a Git repository in the specified directory if it doesn't already exist.
- *
- * @async
- * @param {import('pino.').BaseLogger} - The logger object for logging messages.
- * @param {string} dir - The directory where the Git repository should be initialized.
- * @returns {Promise<boolean>} A Promise that resolves to true if the Git repository is successfully initialized, false otherwise.
- */
-async function gitInit (logger, dir) {
-  try {
-    if (await doesGitRepositoryExist(dir)) {
-      logger.info('Git repository already exists.')
-      return false
-    }
-
-    await execa('git', ['init', '-b', GIT_MAIN_BRANCH], { cwd: dir })
-    logger.debug('Git repository initialized.')
-    return true
-  } catch (err) {
-    logger.error('Git repository init failed.')
-    logger.debug({ err })
-    return false
-  }
-}
-
-/**
- * Commits changes in a Git repository located in the specified directory.
- *
- * @async
- * @param {import('pino.').BaseLogger} - The logger object for logging messages.
- * @param {string} dir - The directory of the Git repository where changes should be committed.
- * @returns {Promise<boolean>} A Promise that resolves to true if the Git commit is successful, false otherwise.
- */
-async function gitCommit (logger, dir) {
-  try {
-    await execa('git', ['add', '-A'], { cwd: dir })
-    await execa('git', ['commit', '-n', '-m', GIT_FIRST_COMMIT_MESSAGE], { cwd: dir })
-    logger.debug('Git commit done.')
-    return true
-  } catch (err) {
-    console.log(err)
-    logger.error('Git commit failed.')
-    logger.debug({ err })
-    return false
-  }
-}

package/src/index.mjs

@@ -1,486 +0,0 @@
-import { ImportGenerator } from '@platformatic/generators'
-import {
-  createDirectory,
-  detectApplicationType,
-  executeWithTimeout,
-  findConfigurationFileRecursive,
-  generateDashedName,
-  getPkgManager,
-  loadConfigurationFile,
-  searchJavascriptFiles
-} from '@platformatic/utils'
-import { execa } from 'execa'
-import defaultInquirer from 'inquirer'
-import parseArgs from 'minimist'
-import { existsSync } from 'node:fs'
-import { readFile, writeFile } from 'node:fs/promises'
-import { basename, dirname, join, resolve } from 'node:path'
-import { fileURLToPath, pathToFileURL } from 'node:url'
-import ora from 'ora'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import resolveModule from 'resolve'
-import { request } from 'undici'
-import { createGitRepository } from './create-git-repository.mjs'
-import { findComposerConfigFile, getUsername, getVersion, say } from './utils.mjs'
-const MARKETPLACE_HOST = 'https://marketplace.platformatic.dev'
-const defaultStackables = ['@platformatic/service', '@platformatic/composer', '@platformatic/db']
-
-export async function fetchStackables (marketplaceHost, modules = []) {
-  const stackables = new Set([...modules, ...defaultStackables])
-
-  // Skip the remote network request if we are running tests
-  if (process.env.MARKETPLACE_TEST) {
-    return Array.from(stackables)
-  }
-
-  let response
-  try {
-    response = await executeWithTimeout(request(new URL('/templates', marketplaceHost || MARKETPLACE_HOST)), 5000)
-  } catch (err) {
-    // No-op: we just use the default stackables
-  }
-
-  if (response && response.statusCode === 200) {
-    for (const stackable of await response.body.json()) {
-      stackables.add(stackable.name)
-    }
-  }
-
-  return Array.from(stackables)
-}
-
-export async function chooseStackable (inquirer, stackables) {
-  const options = await inquirer.prompt({
-    type: 'list',
-    name: 'type',
-    message: 'Which kind of service do you want to create?',
-    default: stackables[0],
-    choices: stackables
-  })
-
-  return options.type
-}
-
-async function getPackageVersion (pkg, projectDir) {
-  let main
-  try {
-    main = import.meta.resolve(pkg)
-  } catch {
-    main = resolveModule.sync(pkg, { basedir: projectDir })
-  }
-
-  if (main.startsWith('file:')) {
-    main = fileURLToPath(main)
-  }
-
-  let root = dirname(main)
-
-  while (!existsSync(join(root, 'package.json'))) {
-    const parent = dirname(root)
-
-    if (parent === root) {
-      // We reached the root of the filesystem
-      throw new Error(`Could not find package.json for ${pkg}.`)
-    }
-
-    root = parent
-  }
-
-  const packageJsonPath = JSON.parse(await readFile(join(root, 'package.json'), 'utf-8'))
-  return packageJsonPath.version
-}
-
-async function importOrLocal ({ pkgManager, name, projectDir, pkg }) {
-  try {
-    return await import(pkg)
-  } catch (err) {
-    try {
-      const fileToImport = resolveModule.sync(pkg, { basedir: projectDir })
-      return await import(pathToFileURL(fileToImport))
-    } catch {
-      // No-op
-    }
-
-    let version = ''
-
-    if (defaultStackables.includes(pkg) || pkg === '@platformatic/runtime') {
-      // Let's find if we are using one of the default stackables
-      // If we are, we have to use the "local" version of the package
-
-      const meta = await JSON.parse(await readFile(join(import.meta.dirname, '..', 'package.json'), 'utf-8'))
-      if (meta.version.includes('-')) {
-        version = `@${meta.version}`
-      } else {
-        version = `@^${meta.version}`
-      }
-    }
-
-    const spinner = ora(`Installing ${pkg + version} using ${pkgManager} ...`).start()
-    const args = []
-
-    if (pkgManager === 'pnpm' && existsSync(resolve(projectDir, 'pnpm-workspace.yaml'))) {
-      args.push('-w')
-    }
-
-    await execa(pkgManager, ['install', ...args, pkg + version], { cwd: projectDir })
-    spinner.succeed()
-
-    const fileToImport = resolveModule.sync(pkg, { basedir: projectDir })
-    return await import(pathToFileURL(fileToImport))
-  }
-}
-
-async function findApplicationRoot (projectDir) {
-  if (existsSync(resolve(projectDir, 'package.json'))) {
-    return projectDir
-  }
-
-  const files = await searchJavascriptFiles(projectDir)
-
-  if (files.length > 0) {
-    return dirname(resolve(projectDir, files[0]))
-  }
-
-  return null
-}
-
-export async function wrapApplication (
-  logger,
-  inquirer,
-  packageManager,
-  module,
-  install,
-  projectDir,
-  additionalGeneratorOptions = {},
-  additionalGeneratorConfig = {}
-) {
-  const projectName = basename(projectDir)
-
-  const runtime = await importOrLocal({
-    pkgManager: packageManager,
-    name: projectName,
-    projectDir,
-    pkg: '@platformatic/runtime'
-  })
-
-  const generator = new runtime.WrappedGenerator({
-    logger,
-    module,
-    name: projectName,
-    inquirer,
-    ...additionalGeneratorOptions
-  })
-  generator.setConfig({
-    ...generator.config,
-    ...additionalGeneratorConfig,
-    targetDirectory: projectDir,
-    typescript: false
-  })
-
-  await generator.ask()
-  await generator.prepare()
-  await generator.writeFiles()
-
-  if (install) {
-    logger.info(`Installing dependencies for the application using ${packageManager} ...`)
-    await execa(packageManager, ['install'], { cwd: projectDir, stdio: 'inherit' })
-  }
-
-  logger.info(`You are all set! Run \`${packageManager} start\` to start your project.`)
-}
-
-export async function createPlatformatic (argv) {
-  const args = parseArgs(argv, {
-    default: {
-      install: true,
-      module: []
-    },
-    boolean: ['install'],
-    string: ['global-config', 'marketplace-host', 'module']
-  })
-
-  const username = await getUsername()
-  const version = await getVersion()
-  const greeting = username ? `Hello ${username},` : 'Hello,'
-  await say(`${greeting} welcome to ${version ? `Platformatic ${version}!` : 'Platformatic!'}`)
-
-  const logger = pino(
-    pretty({
-      translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid'
-    })
-  )
-
-  const pkgManager = getPkgManager()
-  const modules = Array.isArray(args.module) ? args.module : [args.module]
-  await createApplication(logger, pkgManager, modules, args['marketplace-host'], args['install'])
-}
-
-export async function createApplication (
-  logger,
-  packageManager,
-  modules,
-  marketplaceHost,
-  install,
-  additionalGeneratorOptions = {},
-  additionalGeneratorConfig = {}
-) {
-  // This is only used for testing for now, but might be useful in the future
-  const inquirer = process.env.USER_INPUT_HANDLER ? await import(process.env.USER_INPUT_HANDLER) : defaultInquirer
-
-  // Check in the directory and its parents if there is a config file
-  let shouldChooseProjectDir = true
-  let projectDir = process.cwd()
-  const runtimeConfigFile = await findConfigurationFileRecursive(projectDir, null, '@platformatic/runtime')
-
-  if (runtimeConfigFile) {
-    shouldChooseProjectDir = false
-    projectDir = dirname(runtimeConfigFile)
-  } else {
-    // Check the current directory for suitable config files
-    const applicationRoot = await findApplicationRoot(projectDir)
-
-    if (applicationRoot) {
-      // detectApplicationType cannot throw here as findApplicationRoot already checks for the existence of Javascript files
-      const { name: module, label } = await detectApplicationType(projectDir)
-
-      // Check if the file belongs to a Watt application, this can happen for instance if we executed watt create
-      // in the services folder
-      const existingRuntime = await findConfigurationFileRecursive(applicationRoot, null, '@platformatic/runtime')
-
-      if (!existingRuntime) {
-        // If there is a watt.json file with a runtime property, we assume we already executed watt create and we exit.
-        const existingService = await findComposerConfigFile(projectDir)
-
-        if (existingService) {
-          const serviceConfig = await loadConfigurationFile(existingService)
-
-          if (serviceConfig.runtime) {
-            await say(`The ${label} application has already been wrapped into Watt.`)
-            return
-          }
-        }
-
-        const { shouldWrap } = await inquirer.prompt({
-          type: 'list',
-          name: 'shouldWrap',
-          message: `This folder seems to already contain a ${label} application. Do you want to wrap into Watt?`,
-          // default: 'yes',
-          choices: [
-            { name: 'yes', value: true },
-            { name: 'no', value: false }
-          ]
-        })
-
-        if (shouldWrap) {
-          return wrapApplication(
-            logger,
-            inquirer,
-            packageManager,
-            module,
-            install,
-            process.cwd(),
-            additionalGeneratorOptions,
-            { ...additionalGeneratorConfig, skipTypescript: true }
-          )
-        }
-      } else {
-        projectDir = dirname(existingRuntime)
-        shouldChooseProjectDir = false
-      }
-    }
-  }
-
-  if (shouldChooseProjectDir) {
-    const optionsDir = await inquirer.prompt({
-      type: 'input',
-      name: 'dir',
-      message: 'Where would you like to create your project?',
-      default: 'platformatic'
-    })
-
-    projectDir = resolve(process.cwd(), optionsDir.dir)
-    await createDirectory(projectDir)
-    process.chdir(projectDir)
-  }
-
-  const projectName = basename(projectDir)
-
-  const runtime = await importOrLocal({
-    pkgManager: packageManager,
-    name: projectName,
-    projectDir,
-    pkg: '@platformatic/runtime'
-  })
-
-  const generator = new runtime.Generator({
-    logger,
-    name: projectName,
-    inquirer,
-    ...additionalGeneratorOptions
-  })
-
-  generator.setConfig({
-    ...generator.config,
-    ...additionalGeneratorConfig,
-    targetDirectory: projectDir
-  })
-
-  await generator.populateFromExistingConfig()
-  if (generator.existingConfig) {
-    await say('Using existing configuration ...')
-  }
-
-  const stackables = await fetchStackables(marketplaceHost, modules)
-
-  const names = generator.existingServices ?? []
-
-  while (true) {
-    const stackableName = await chooseStackable(inquirer, stackables)
-    // await say(`Creating a ${stackable} project in ${projectDir}...`)
-
-    const stackable = await importOrLocal({
-      pkgManager: packageManager,
-      name: projectName,
-      projectDir,
-      pkg: stackableName
-    })
-
-    const { serviceName } = await inquirer.prompt({
-      type: 'input',
-      name: 'serviceName',
-      message: 'What is the name of the service?',
-      default: generateDashedName(),
-      validate: value => {
-        if (value.length === 0) {
-          return 'Please enter a name'
-        }
-
-        if (value.includes(' ')) {
-          return 'Please enter a name without spaces'
-        }
-
-        if (names.includes(value)) {
-          return 'This name is already used, please choose another one.'
-        }
-
-        return true
-      }
-    })
-
-    names.push(serviceName)
-
-    const stackableGenerator = stackable.Generator
-      ? new stackable.Generator({
-        logger,
-        inquirer,
-        serviceName,
-        parent: generator,
-        ...additionalGeneratorOptions
-      })
-      : new ImportGenerator({
-        logger,
-        inquirer,
-        serviceName,
-        module: stackableName,
-        version: await getPackageVersion(stackableName, projectDir),
-        parent: generator,
-        ...additionalGeneratorOptions
-      })
-
-    stackableGenerator.setConfig({
-      ...stackableGenerator.config,
-      ...additionalGeneratorConfig,
-      serviceName
-    })
-
-    generator.addService(stackableGenerator, serviceName)
-
-    await stackableGenerator.ask()
-
-    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 = ''
-  const chooseEntrypoint = names.length > 1 && (!generator.existingConfigRaw || !generator.existingConfigRaw.entrypoint)
-
-  if (chooseEntrypoint) {
-    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]
-  }
-
-  generator.setEntryPoint(entrypoint)
-
-  await generator.ask()
-  await generator.prepare()
-
-  if (chooseEntrypoint) {
-    await generator.updateConfigEntryPoint(entrypoint)
-  }
-
-  await generator.writeFiles()
-
-  // Create project here
-  if (!generator.existingConfigRaw) {
-    const { initGitRepository } = await inquirer.prompt({
-      type: 'list',
-      name: 'initGitRepository',
-      message: 'Do you want to init the git repository?',
-      default: false,
-      choices: [
-        { name: 'yes', value: true },
-        { name: 'no', value: false }
-      ]
-    })
-
-    if (initGitRepository) {
-      await createGitRepository(logger, projectDir)
-    }
-  }
-
-  if (packageManager === 'pnpm') {
-    // add pnpm-workspace.yaml file if needed
-    const content = `packages:
-# all packages in direct subdirs of packages/
-- 'services/*'
-- 'web/*'`
-    await writeFile(join(projectDir, 'pnpm-workspace.yaml'), content)
-  }
-
-  if (typeof install === 'function') {
-    await install(projectDir, generator.runtimeConfig, packageManager)
-  } else if (install) {
-    const spinner = ora('Installing dependencies...').start()
-    await execa(packageManager, ['install'], { cwd: projectDir })
-    spinner.succeed()
-  }
-
-  logger.info('Project created successfully, executing post-install actions...')
-  await generator.postInstallActions()
-  logger.info(`You are all set! Run \`${packageManager} start\` to start your project.`)
-}

package/src/utils.mjs

@@ -1,156 +0,0 @@
-import { findConfigurationFile } from '@platformatic/utils'
-import { execa } from 'execa'
-import { access, constants, readFile } from 'fs/promises'
-import { createRequire } from 'module'
-import { dirname, join, resolve } from 'path'
-import * as url from 'url'
-
-export const sleep = ms => new Promise(resolve => setTimeout(resolve, ms))
-export const randomBetween = (min, max) => Math.floor(Math.random() * (max - min + 1) + min)
-const __dirname = url.fileURLToPath(new URL('.', import.meta.url))
-
-const ansiCodes = {
-  // Platformatic Green: #21FA90
-  pltGreen: '\u001B[38;2;33;250;144m',
-  bell: '\u0007',
-  reset: '\u001b[0m',
-  erasePreviousLine: '\u001b[1K'
-}
-
-export async function isFileAccessible (filename, directory) {
-  try {
-    const filePath = directory ? resolve(directory, filename) : filename
-    await access(filePath)
-    return true
-  } catch (err) {
-    return false
-  }
-}
-/**
- * Gets the username from git config or `whoami` command
- * @returns string | null
- */
-export const getUsername = async () => {
-  try {
-    const { stdout } = await execa('git', ['config', 'user.name'])
-    if (stdout?.trim()) {
-      return stdout.trim()
-    }
-  } catch (err) {
-    // ignore: git failed
-  }
-  try {
-    const { stdout } = await execa('whoami')
-    if (stdout?.trim()) {
-      return stdout.trim()
-    }
-  } catch (err) {
-    // ignore: whoami failed
-  }
-
-  return null
-}
-/**
- * Get the platformatic package version from package.json
- * @returns string
- */
-/* c8 ignore next 4 */
-export const getVersion = async () => {
-  const data = await readFile(join(import.meta.dirname, '..', 'package.json'), 'utf8')
-  return JSON.parse(data).version
-}
-
-export async function isDirectoryWriteable (directory) {
-  try {
-    await access(directory, constants.R_OK | constants.W_OK)
-    return true
-  } catch (err) {
-    return false
-  }
-}
-
-export const findConfigFile = async directory => findConfigurationFile(directory)
-export const findDBConfigFile = async directory => findConfigurationFile(directory, 'db')
-export const findServiceConfigFile = async directory => findConfigurationFile(directory, 'service')
-export const findComposerConfigFile = async directory => findConfigurationFile(directory, 'composer')
-export const findRuntimeConfigFile = async directory => findConfigurationFile(directory, 'runtime')
-
-/**
- * Gets the version of the specified dependency package from package.json
- * @param {string} dependencyName
- * @returns string
- */
-export const getDependencyVersion = async dependencyName => {
-  const rootPackageJson = join(__dirname, '..', 'package.json')
-  const packageJsonContents = JSON.parse(await readFile(rootPackageJson, 'utf8'))
-  const dependencies = packageJsonContents.dependencies
-  const devDependencies = packageJsonContents.devDependencies
-  const regexp = /(0|[1-9]\d*)\.(0|[1-9]\d*)\.(0|[1-9]\d*)/
-  if (dependencies[dependencyName]) {
-    const match = dependencies[dependencyName].match(regexp)
-    if (!match) {
-      return await resolveWorkspaceDependency(dependencyName)
-    }
-    return match[0]
-  }
-
-  if (devDependencies[dependencyName]) {
-    const match = devDependencies[dependencyName].match(regexp)
-    if (!match) {
-      return await resolveWorkspaceDependency(dependencyName)
-    }
-    return match[0]
-  }
-
-  async function resolveWorkspaceDependency (dependencyName) {
-    const require = createRequire(import.meta.url)
-    let dependencyPath = dirname(require.resolve(dependencyName))
-    // some deps are resolved not at their root level
-    // for instance 'typescript' will be risolved in its own ./lib directory
-    // next loop is to find the nearest parent directory that contains a package.json file
-    while (!(await isFileAccessible(join(dependencyPath, 'package.json')))) {
-      dependencyPath = join(dependencyPath, '..')
-      if (dependencyPath === '/') {
-        throw new Error(`Cannot find package.json for ${dependencyName}`)
-      }
-    }
-    const pathToPackageJson = join(dependencyPath, 'package.json')
-    const packageJsonFile = await readFile(pathToPackageJson, 'utf-8')
-    const packageJson = JSON.parse(packageJsonFile)
-    return packageJson.version
-  }
-}
-
-export function convertServiceNameToPrefix (serviceName) {
-  return serviceName.replace(/-/g, '_').toUpperCase()
-}
-
-export function addPrefixToEnv (env, prefix) {
-  const output = {}
-  Object.entries(env).forEach(([key, value]) => {
-    output[`${prefix}_${key}`] = value
-  })
-  return output
-}
-
-export async function say (message) {
-  // Disable if not supporting colors
-  if (process.env.NO_COLOR) {
-    console.log(message)
-    return
-  }
-
-  const words = message.split(' ')
-
-  for (let i = 0; i <= words.length; i++) {
-    if (i > 0) {
-      process.stdout.write('\r' + ansiCodes.erasePreviousLine)
-    }
-
-    process.stdout.write(ansiCodes.pltGreen + words.slice(0, i).join(' ') + ansiCodes.reset + ansiCodes.bell)
-    await sleep(randomBetween(75, 100))
-  }
-
-  process.stdout.write('\n')
-  await sleep(randomBetween(75, 200))
-}