create-platformatic 1.17.0 → 1.19.0

package/create-platformatic.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import createPlatformatic from './src/index.mjs'
+import { createPlatformatic } from '@platformatic/create-platformatic-auto'
 import isMain from 'es-main'
 import parseArgs from 'minimist'
 import { readFile } from 'fs/promises'
@@ -30,12 +30,7 @@ if (isMain(import.meta)) {
   await createPlatformatic(_args)
 }
 
-export { default as createDB } from './src/db/create-db.mjs'
-export { parseDBArgs } from './src/db/create-db-cli.mjs'
 export {
   createStaticWorkspaceGHAction,
   createDynamicWorkspaceGHAction
 } from './src/ghaction.mjs'
-
-export { createGitignore, createGitRepository, createPackageJson, getDependencyVersion, getVersion } from './src/index.mjs'
-export { default as createService } from './src/service/create-service.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "1.17.0",
+  "version": "1.19.0",
   "description": "Create platformatic-db interactive tool",
   "repository": {
     "type": "git",
@@ -36,8 +36,9 @@
     "strip-ansi": "^7.1.0",
     "undici": "^6.0.0",
     "which": "^3.0.1",
-    "@platformatic/utils": "1.17.0",
-    "@platformatic/config": "1.17.0"
+    "@platformatic/create-platformatic-auto": "1.19.0",
+    "@platformatic/utils": "1.19.0",
+    "@platformatic/config": "1.19.0"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
@@ -49,8 +50,8 @@
     "standard": "^17.1.0",
     "typescript": "~5.3.0",
     "yaml": "^2.3.2",
-    "@platformatic/db": "1.17.0",
-    "@platformatic/service": "1.17.0"
+    "@platformatic/db": "1.19.0",
+    "@platformatic/service": "1.19.0"
   },
   "scripts": {
     "test:cli": "node --test ./test/cli",

package/src/ghaction.mjs

@@ -2,6 +2,7 @@ import { join } from 'path'
 import { isFileAccessible, safeMkdir } from './utils.mjs'
 import { writeFile } from 'fs/promises'
 import columnify from 'columnify'
+
 function envAsString (env, indent) {
   const spaces = ' '.repeat(indent * 2)
   return Object.keys(env).reduce((acc, key) => {

package/src/utils.mjs

@@ -1,16 +1,5 @@
-import { execa } from 'execa'
-import { access, constants, mkdir, readFile } from 'fs/promises'
-import { resolve, join, dirname } from 'path'
-import { createRequire } from 'module'
-import semver from 'semver'
-import * as desm from 'desm'
-import * as url from 'url'
-
-import ConfigManager from '@platformatic/config'
-
-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))
+import { access, mkdir } from 'fs/promises'
+import { resolve } from 'path'
 
 export async function isFileAccessible (filename, directory) {
   try {
@@ -21,123 +10,6 @@ export async function isFileAccessible (filename, directory) {
     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(desm.join(import.meta.url, '..', '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) => (ConfigManager.findConfigFile(directory))
-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'))
-
-/**
- * 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 const minimumSupportedNodeVersions = ['18.8.0', '20.6.0']
-
-export const isCurrentVersionSupported = (currentVersion) => {
-  // TODO: add try/catch if some unsupported node version is passed
-  for (const version of minimumSupportedNodeVersions) {
-    if (semver.major(currentVersion) === semver.major(version) && semver.gte(currentVersion, version)) {
-      return true
-    }
-  }
-  return false
-}
-
-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 safeMkdir (dir) {
   try {

package/src/ask-dir.mjs

@@ -1,37 +0,0 @@
-'use strict'
-
-import { stat } from 'fs/promises'
-import inquirer from 'inquirer'
-import { resolve } from 'path'
-
-const askProjectDir = async (logger, defaultName, message = 'Where would you like to create your project?') => {
-  const options = await inquirer.prompt({
-    type: 'input',
-    name: 'dir',
-    message,
-    default: defaultName
-  })
-
-  const projectDir = resolve(process.cwd(), options.dir)
-
-  try {
-    await stat(projectDir)
-    logger.warn(`Directory ${projectDir} is not empty. Some files may be overwritten without confirmation.`)
-    const confirmation = await inquirer.prompt({
-      type: 'list',
-      name: 'confirmExistingDirectory',
-      message: `Confirm you want to use ${projectDir} directory?`,
-      default: 'no',
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    })
-    if (!confirmation.confirmExistingDirectory) {
-      logger.error('Please choose another directory.')
-      process.exit(1)
-    }
-  } catch (err) {
-    // directory is empty, we can proceed
-  }
-  return projectDir
-}
-
-export default askProjectDir

package/src/cli-options.mjs

@@ -1,34 +0,0 @@
-export const getUseTypescript = typescript => {
-  return {
-    type: 'list',
-    when: !typescript,
-    name: 'useTypescript',
-    message: 'Do you want to use TypeScript?',
-    default: typescript,
-    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-  }
-}
-
-export const getInitGitRepository = () => {
-  return {
-    type: 'list',
-    name: 'initGitRepository',
-    message: 'Do you want to init the git repository?',
-    default: false,
-    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/colors.mjs

@@ -1,4 +0,0 @@
-import chalk, { supportsColor } from 'chalk'
-const useColor = supportsColor && !process.env.NO_COLOR
-const noop = (str) => str
-export const pltGreen = useColor ? chalk.hex('#21FA90') : noop

package/src/composer/README.md

@@ -1,30 +0,0 @@
-# Platformatic Composer API
-
-This is a generated [Platformatic Composer](https://docs.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 or >= v20.6.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

@@ -1,143 +0,0 @@
-import { getVersion, getDependencyVersion, safeMkdir } from '../utils.mjs'
-import { createPackageJson } from '../create-package-json.mjs'
-import { createGitignore } from '../create-gitignore.mjs'
-import { getPkgManager } from '@platformatic/utils'
-import parseArgs from 'minimist'
-import inquirer from 'inquirer'
-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 { getPort, getUseTypescript, getInitGitRepository } from '../cli-options.mjs'
-import { createReadme } from '../create-readme.mjs'
-import { join } from 'path'
-
-export const getServicesToCompose = (servicesNames) => {
-  return {
-    type: 'checkbox',
-    name: 'servicesToCompose',
-    message: 'Which services do you want to expose via Platformatic Composer?',
-    choices: servicesNames,
-    default: []
-  }
-}
-
-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',
-      install: true
-    },
-    alias: {
-      h: 'hostname',
-      p: 'port'
-    },
-    boolean: ['install']
-  })
-
-  const version = await getVersion()
-  const pkgManager = getPkgManager()
-
-  const projectDir = opts.dir || await askDir(logger, join('.', 'platformatic-composer'))
-  const isRuntimeContext = opts.isRuntimeContext || false
-
-  const toAsk = []
-
-  // Ask for port if not in runtime context
-  const portQuestion = getPort(args.port)
-  portQuestion.when = !isRuntimeContext
-  toAsk.push(portQuestion)
-  toAsk.push(getUseTypescript(args.typescript))
-
-  if (isRuntimeContext) {
-    const servicesNames = opts.runtimeContext.servicesNames.filter(
-      (serviceName) => serviceName !== opts.serviceName
-    )
-    if (servicesNames.length > 0) {
-      toAsk.push(getServicesToCompose(servicesNames))
-    }
-  }
-
-  if (!opts.skipGitHubActions) {
-    toAsk.push({
-      type: 'list',
-      name: 'staticWorkspaceGitHubAction',
-      message: 'Do you want to create the github action to deploy this application to Platformatic Cloud?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    },
-    {
-      type: 'list',
-      name: 'dynamicWorkspaceGitHubAction',
-      message: 'Do you want to enable PR Previews in your application?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    })
-  }
-
-  if (!opts.skipGitRepository) {
-    toAsk.push(getInitGitRepository())
-  }
-  const {
-    servicesToCompose,
-    port,
-    staticWorkspaceGitHubAction,
-    dynamicWorkspaceGitHubAction,
-    useTypescript,
-    initGitRepository
-  } = await inquirer.prompt(toAsk)
-
-  // Create the project directory
-  await safeMkdir(projectDir)
-
-  const params = {
-    isRuntimeContext,
-    hostname: args.hostname,
-    port,
-    servicesToCompose,
-    staticWorkspaceGitHubAction,
-    dynamicWorkspaceGitHubAction,
-    runtimeContext: opts.runtimeContext,
-    typescript: useTypescript,
-    initGitRepository
-  }
-
-  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(version, fastifyVersion, logger, projectDir, useTypescript)
-  }
-  if (!opts.skipGitignore) {
-    await createGitignore(logger, projectDir)
-  }
-  await createReadme(logger, projectDir, 'composer')
-
-  if (args.install && !opts.skipPackageJson) {
-    const spinner = ora('Installing dependencies...').start()
-    await execa(pkgManager, ['install'], { cwd: projectDir })
-    spinner.succeed()
-  }
-
-  // returns metadata that can be used to make some further actions
-  return {
-    typescript: useTypescript
-  }
-}
-
-export default createPlatformaticComposer

package/src/composer/create-composer.mjs

@@ -1,146 +0,0 @@
-import { readFile, writeFile, appendFile } from 'fs/promises'
-import { join } from 'path'
-import * as desm from 'desm'
-import { generatePlugins } from '../create-plugins.mjs'
-import { createDynamicWorkspaceGHAction, createStaticWorkspaceGHAction } from '../ghaction.mjs'
-import { getTsConfig } from '../get-tsconfig.mjs'
-import { createGitRepository } from '../create-git-repository.mjs'
-
-const TS_OUT_DIR = 'dist'
-
-function generateConfig (isRuntimeContext, version, servicesToCompose, typescript, envPrefix) {
-  const config = {
-    $schema: `https://platformatic.dev/schemas/v${version}/composer`,
-    composer: {
-      services: [{
-        id: 'example',
-        origin: `{PLT_${envPrefix}EXAMPLE_ORIGIN}`,
-        openapi: {
-          url: '/documentation/json'
-        }
-      }],
-      refreshTimeout: 1000
-    },
-    watch: true,
-    plugins: {
-      paths: [
-        { path: './plugins', encapsulate: false },
-        './routes'
-      ]
-    }
-  }
-
-  if (!isRuntimeContext) {
-    config.server = {
-      hostname: '{PLT_SERVER_HOSTNAME}',
-      port: '{PORT}',
-      logger: {
-        level: '{PLT_SERVER_LOGGER_LEVEL}'
-      }
-    }
-  } else {
-    config.composer.services = servicesToCompose.map((serviceName) => {
-      return {
-        id: serviceName,
-        openapi: {
-          url: '/documentation/json',
-          prefix: `/${serviceName}`
-        }
-      }
-    })
-  }
-
-  if (typescript === true && config.plugins) {
-    config.plugins.typescript = `{PLT_${envPrefix}TYPESCRIPT}`
-  }
-
-  return config
-}
-
-function generateEnv (isRuntimeContext, hostname, port, typescript, envPrefix) {
-  let env = ''
-
-  if (!isRuntimeContext) {
-    env += `\
-PLT_SERVER_HOSTNAME=${hostname}
-PORT=${port}
-PLT_SERVER_LOGGER_LEVEL=info`
-  }
-  env += `
-PLT_${envPrefix}EXAMPLE_ORIGIN=
-`
-  if (typescript === true) {
-    env += `\
-# Set to false to disable automatic typescript compilation.
-# Changing this setting is needed for production
-PLT_${envPrefix}TYPESCRIPT=true
-`
-  }
-  return env
-}
-
-async function createComposer (
-  params,
-  logger,
-  currentDir = process.cwd(),
-  version
-) {
-  const {
-    isRuntimeContext,
-    hostname,
-    port,
-    servicesToCompose = [],
-    runtimeContext,
-    typescript,
-    staticWorkspaceGitHubAction,
-    dynamicWorkspaceGitHubAction,
-    initGitRepository
-  } = params
-
-  const composerEnv = {
-    PLT_SERVER_LOGGER_LEVEL: 'info',
-    PORT: port,
-    PLT_SERVER_HOSTNAME: hostname
-  }
-  if (!version) {
-    const pkg = await readFile(desm.join(import.meta.url, '..', '..', 'package.json'))
-    version = JSON.parse(pkg).version
-  }
-  const envPrefix = runtimeContext !== undefined ? `${runtimeContext.envPrefix}_` : ''
-
-  const config = generateConfig(isRuntimeContext, version, servicesToCompose, typescript, envPrefix)
-  await writeFile(join(currentDir, 'platformatic.composer.json'), JSON.stringify(config, null, 2))
-  logger.info('Configuration file platformatic.composer.json successfully created.')
-
-  const env = generateEnv(isRuntimeContext, hostname, port, typescript, envPrefix)
-  await appendFile(join(currentDir, '.env'), env)
-  await writeFile(join(currentDir, '.env.sample'), env)
-  /* c8 ignore next 5 */
-  logger.info('Environment file .env successfully created.')
-  await generatePlugins(logger, currentDir, typescript, 'composer')
-
-  if (typescript === true) {
-    const tsConfigFileName = join(currentDir, 'tsconfig.json')
-    const tsConfig = getTsConfig(TS_OUT_DIR)
-    await writeFile(tsConfigFileName, JSON.stringify(tsConfig, null, 2))
-    logger.info(`Typescript configuration file ${tsConfigFileName} successfully created.`)
-
-    // TODO: global.d.ts is needed to compile the project. Still need to populate it
-    await writeFile(join(currentDir, 'global.d.ts'), '')
-  }
-
-  if (staticWorkspaceGitHubAction) {
-    await createStaticWorkspaceGHAction(logger, composerEnv, './platformatic.service.json', currentDir, typescript)
-  }
-  if (dynamicWorkspaceGitHubAction) {
-    await createDynamicWorkspaceGHAction(logger, composerEnv, './platformatic.service.json', currentDir, typescript)
-  }
-
-  if (initGitRepository) {
-    await createGitRepository(logger, currentDir)
-  }
-
-  return composerEnv
-}
-
-export default createComposer