create-platformatic 2.63.4 → 2.65.0

package/create-platformatic.mjs

@@ -23,4 +23,5 @@ if (isMain(import.meta)) {
   await createPlatformatic(_args)
 }
 
-export { createPlatformatic }
+export * from './src/index.mjs'
+export * from './src/utils.mjs'

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "2.63.4",
+  "version": "2.65.0",
   "description": "Create platformatic application interactive tool",
   "repository": {
     "type": "git",
@@ -15,7 +15,6 @@
   "license": "Apache-2.0",
   "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "dependencies": {
-    "chalk": "^5.3.0",
     "columnify": "^1.6.0",
     "commist": "^3.2.0",
     "desm": "^1.3.1",
@@ -23,7 +22,6 @@
     "execa": "^9.0.0",
     "help-me": "^5.0.0",
     "inquirer": "^9.2.16",
-    "log-update": "^6.0.0",
     "minimist": "^1.2.8",
     "ora": "^6.3.1",
     "pino": "^9.0.0",
@@ -33,9 +31,9 @@
     "strip-ansi": "^7.1.0",
     "undici": "^7.0.0",
     "which": "^3.0.1",
-    "@platformatic/config": "2.63.4",
-    "@platformatic/generators": "2.63.4",
-    "@platformatic/utils": "2.63.4"
+    "@platformatic/config": "2.65.0",
+    "@platformatic/utils": "2.65.0",
+    "@platformatic/generators": "2.65.0"
   },
   "devDependencies": {
     "@types/node": "^22.5.0",
@@ -50,10 +48,10 @@
     "neostandard": "^0.12.0",
     "typescript": "~5.8.0",
     "yaml": "^2.4.1",
-    "@platformatic/composer": "2.63.4",
-    "@platformatic/db": "2.63.4",
-    "@platformatic/runtime": "2.63.4",
-    "@platformatic/service": "2.63.4"
+    "@platformatic/composer": "2.65.0",
+    "@platformatic/db": "2.65.0",
+    "@platformatic/runtime": "2.65.0",
+    "@platformatic/service": "2.65.0"
   },
   "scripts": {
     "test:cli": "borp --pattern \"test/cli/*test.mjs\" --timeout=300000 --concurrency=1",

package/src/index.mjs

@@ -1,11 +1,10 @@
 import { ConfigManager } from '@platformatic/config'
-import { createDirectory, generateDashedName, getPkgManager } from '@platformatic/utils'
+import { createDirectory, executeWithTimeout, generateDashedName, getPkgManager } from '@platformatic/utils'
 import { execa } from 'execa'
-import inquirer from 'inquirer'
+import defaultInquirer from 'inquirer'
 import parseArgs from 'minimist'
 import { readFile, writeFile } from 'node:fs/promises'
-import path, { basename, join } from 'node:path'
-import { setTimeout } from 'node:timers/promises'
+import { basename, join, resolve as pathResolve } from 'node:path'
 import { pathToFileURL } from 'node:url'
 import ora from 'ora'
 import pino from 'pino'
@@ -13,40 +12,41 @@ import pretty from 'pino-pretty'
 import resolve from 'resolve'
 import { request } from 'undici'
 import { createGitRepository } from './create-git-repository.mjs'
-import { say } from './say.mjs'
-import { getUsername, getVersion } from './utils.mjs'
-
+import { getUsername, getVersion, say } from './utils.mjs'
 const MARKETPLACE_HOST = 'https://marketplace.platformatic.dev'
-const defaultStackables = ['@platformatic/composer', '@platformatic/db', '@platformatic/service']
+const defaultStackables = ['@platformatic/service', '@platformatic/composer', '@platformatic/db']
+
+export async function fetchStackables (marketplaceHost, modules = []) {
+  const stackables = new Set([...modules, ...defaultStackables])
 
-export async function fetchStackables (marketplaceHost) {
   // Skip the remote network request if we are running tests
   if (process.env.MARKETPLACE_TEST) {
-    return [...defaultStackables]
+    return Array.from(stackables)
   }
 
-  marketplaceHost = marketplaceHost || MARKETPLACE_HOST
-
-  const stackablesRequest = request(marketplaceHost + '/templates')
-  const stackablesRequestTimeout = setTimeout(5000, new Error('Request timed out'))
-
+  let response
   try {
-    const { statusCode, body } = await Promise.race([stackablesRequest, stackablesRequestTimeout])
-    if (statusCode === 200) {
-      return (await body.json()).map(stackable => stackable.name)
+    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)
     }
-  } catch (err) {}
+  }
 
-  return [...defaultStackables]
+  return Array.from(stackables)
 }
 
-export async function chooseStackable (stackables) {
+export async function chooseStackable (inquirer, stackables) {
   const options = await inquirer.prompt({
     type: 'list',
     name: 'type',
-    message: 'Which kind of project do you want to create?',
-    default: stackables.indexOf('@platformatic/service'),
-    choices: stackables,
+    message: 'Which kind of service do you want to create?',
+    default: stackables[0],
+    choices: stackables
   })
 
   return options.type
@@ -59,7 +59,9 @@ async function importOrLocal ({ pkgManager, name, projectDir, pkg }) {
     try {
       const fileToImport = resolve.sync(pkg, { basedir: projectDir })
       return await import(pathToFileURL(fileToImport))
-    } catch {}
+    } catch {
+      // No-op
+    }
 
     let version = ''
 
@@ -84,13 +86,14 @@ async function importOrLocal ({ pkgManager, name, projectDir, pkg }) {
   }
 }
 
-export const createPlatformatic = async argv => {
+export async function createPlatformatic (argv) {
   const args = parseArgs(argv, {
     default: {
       install: true,
+      module: []
     },
     boolean: ['install'],
-    string: ['global-config', 'marketplace-host'],
+    string: ['global-config', 'marketplace-host', 'module']
   })
 
   const username = await getUsername()
@@ -101,65 +104,78 @@ export const createPlatformatic = async argv => {
   const logger = pino(
     pretty({
       translateTime: 'SYS:HH:MM:ss',
-      ignore: 'hostname,pid',
+      ignore: 'hostname,pid'
     })
   )
 
   const pkgManager = getPkgManager()
-  await createApplication(args, logger, pkgManager)
+  const modules = Array.isArray(args.module) ? args.module : [args.module]
+  await createApplication(logger, pkgManager, modules, args['marketplace-host'], args['install'])
 }
 
-async function createApplication (args, logger, pkgManager) {
+export async function createApplication (
+  logger,
+  packageManager,
+  modules,
+  marketplaceHost,
+  install,
+  additionalGeneratorOptions = {}
+) {
+  // This is only used for testing for now, but might be useful in the future
+  const inquirer = process.env.INQUIRER_PATH ? await import(process.env.INQUIRER_PATH) : defaultInquirer
+
   let projectDir = process.cwd()
   if (!(await ConfigManager.findConfigFile())) {
     const optionsDir = await inquirer.prompt({
       type: 'input',
       name: 'dir',
       message: 'Where would you like to create your project?',
-      default: 'platformatic',
+      default: 'platformatic'
     })
 
-    projectDir = path.resolve(process.cwd(), optionsDir.dir)
+    projectDir = pathResolve(process.cwd(), optionsDir.dir)
   }
   const projectName = basename(projectDir)
 
   await createDirectory(projectDir)
 
   const runtime = await importOrLocal({
-    pkgManager,
+    pkgManager: packageManager,
     name: projectName,
     projectDir,
-    pkg: '@platformatic/runtime',
+    pkg: '@platformatic/runtime'
   })
 
   const generator = new runtime.Generator({
     logger,
     name: projectName,
     inquirer,
+    ...additionalGeneratorOptions
   })
+
   generator.setConfig({
     ...generator.config,
-    targetDirectory: projectDir,
+    targetDirectory: projectDir
   })
 
   await generator.populateFromExistingConfig()
   if (generator.existingConfig) {
-    await say('Using existing configuration')
+    await say('Using existing configuration ...')
   }
 
-  const stackables = await fetchStackables(args['marketplace-host'])
+  const stackables = await fetchStackables(marketplaceHost, modules)
 
-  const names = []
+  const names = generator.existingServices ?? []
 
   while (true) {
-    const stackableName = await chooseStackable(stackables)
+    const stackableName = await chooseStackable(inquirer, stackables)
     // await say(`Creating a ${stackable} project in ${projectDir}...`)
 
     const stackable = await importOrLocal({
-      pkgManager,
+      pkgManager: packageManager,
       name: projectName,
       projectDir,
-      pkg: stackableName,
+      pkg: stackableName
     })
 
     const { serviceName } = await inquirer.prompt({
@@ -181,19 +197,19 @@ async function createApplication (args, logger, pkgManager) {
         }
 
         return true
-      },
+      }
     })
 
     names.push(serviceName)
 
     const stackableGenerator = new stackable.Generator({
       logger,
-      inquirer,
+      inquirer
     })
 
     stackableGenerator.setConfig({
       ...stackableGenerator.config,
-      serviceName,
+      serviceName
     })
 
     generator.addService(stackableGenerator, serviceName)
@@ -208,9 +224,9 @@ async function createApplication (args, logger, pkgManager) {
         default: false,
         choices: [
           { name: 'yes', value: false },
-          { name: 'no', value: true },
-        ],
-      },
+          { name: 'no', value: true }
+        ]
+      }
     ])
 
     if (shouldBreak) {
@@ -219,15 +235,16 @@ async function createApplication (args, logger, pkgManager) {
   }
 
   let entrypoint = ''
+  const chooseEntrypoint = names.length > 1 && (!generator.existingConfigRaw || !generator.existingConfigRaw.entrypoint)
 
-  if (names.length > 1) {
+  if (chooseEntrypoint) {
     const results = await inquirer.prompt([
       {
         type: 'list',
         name: 'entrypoint',
         message: 'Which service should be exposed?',
-        choices: names.map(name => ({ name, value: name })),
-      },
+        choices: names.map(name => ({ name, value: name }))
+      }
     ])
     entrypoint = results.entrypoint
   } else {
@@ -238,40 +255,54 @@ async function createApplication (args, logger, pkgManager) {
 
   await generator.ask()
   await generator.prepare()
+
+  if (chooseEntrypoint) {
+    // This can return null if the generator was not supposed to modify the config
+    const configObject = generator.getFileObject(generator.runtimeConfig)
+    const config = configObject ? JSON.parse(configObject.contents) : generator.existingConfigRaw
+    config.entrypoint = entrypoint
+
+    generator.addFile({ path: '', file: generator.runtimeConfig, contents: JSON.stringify(config, null, 2) })
+  }
+
   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 }
+      ]
+    })
 
-  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 (initGitRepository) {
+      await createGitRepository(logger, projectDir)
+    }
   }
 
-  if (pkgManager === 'pnpm') {
+  if (packageManager === 'pnpm') {
     // add pnpm-workspace.yaml file if needed
     const content = `packages:
 # all packages in direct subdirs of packages/
-- 'services/*'`
+- 'services/*'
+- 'web/*'`
     await writeFile(join(projectDir, 'pnpm-workspace.yaml'), content)
   }
 
-  if (args.install) {
+  if (typeof install === 'function') {
+    await install(projectDir, generator.runtimeConfig, packageManager)
+  } else if (install) {
     const spinner = ora('Installing dependencies...').start()
-    await execa(pkgManager, ['install'], { cwd: projectDir })
+    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 `npm start` to start your project.')
+  logger.info(`You are all set! Run \`${packageManager} start\` to start your project.`)
 }

package/src/utils.mjs

@@ -11,6 +11,14 @@ 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
@@ -118,6 +126,7 @@ export const getDependencyVersion = async dependencyName => {
 export function convertServiceNameToPrefix (serviceName) {
   return serviceName.replace(/-/g, '_').toUpperCase()
 }
+
 export function addPrefixToEnv (env, prefix) {
   const output = {}
   Object.entries(env).forEach(([key, value]) => {
@@ -125,3 +134,25 @@ export function addPrefixToEnv (env, prefix) {
   })
   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))
+}

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/say.mjs

@@ -1,29 +0,0 @@
-import logUpdate from 'log-update'
-import { pltGreen } from './colors.mjs'
-import { randomBetween, sleep } from './utils.mjs'
-
-export async function say (messages) {
-  const _messages = Array.isArray(messages) ? messages : [messages]
-
-  if (process.env.NO_COLOR) {
-    for (const message of _messages) {
-      console.log(message)
-    }
-
-    logUpdate.done()
-    return
-  }
-
-  for (const message of _messages) {
-    const _message = Array.isArray(message) ? message : message.split(' ')
-    const msg = []
-    for (const word of [''].concat(_message)) {
-      msg.push(word)
-      logUpdate(pltGreen(msg.join(' ')))
-      await sleep(randomBetween(75, 100))
-      process.stdout.write('\u0007') // Do we want to enable terminal bell?
-    }
-    await sleep(randomBetween(75, 200))
-  }
-  logUpdate.done()
-}