create-platformatic 1.49.1 → 1.50.0

package/create-platformatic.mjs

@@ -1,5 +1,5 @@
 #!/usr/bin/env node
-import { createPlatformatic } from '@platformatic/create-platformatic-auto'
+import { createPlatformatic } from './src/index.mjs'
 import isMain from 'es-main'
 import parseArgs from 'minimist'
 import { readFile } from 'fs/promises'
@@ -30,7 +30,4 @@ if (isMain(import.meta)) {
   await createPlatformatic(_args)
 }
 
-export {
-  createStaticWorkspaceGHAction,
-  createDynamicWorkspaceGHAction
-} from './src/ghaction.mjs'
+export { createPlatformatic }

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "create-platformatic",
-  "version": "1.49.1",
-  "description": "Create platformatic-db interactive tool",
+  "version": "1.50.0",
+  "description": "Create platformatic application interactive tool",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
@@ -10,10 +10,10 @@
     ".": "./create-platformatic.mjs"
   },
   "bin": {
-    "create-platformatic": "./create-platformatic.mjs"
+    "create-platformatic-auto": "./create-platformatic.mjs"
   },
   "license": "Apache-2.0",
-  "author": "Marco Piraccini <marco.piraccini@gmail.com>",
+  "author": "Matteo Collina <hello@matteocollina.com>",
   "dependencies": {
     "@types/node": "^20.11.28",
     "boring-name-generator": "^1.0.3",
@@ -30,17 +30,19 @@
     "ora": "^6.3.1",
     "pino": "^8.19.0",
     "pino-pretty": "^11.0.0",
+    "resolve": "^1.22.8",
     "semver": "^7.6.0",
     "strip-ansi": "^7.1.0",
     "undici": "^6.9.0",
     "which": "^3.0.1",
-    "@platformatic/config": "1.49.1",
-    "@platformatic/utils": "1.49.1",
-    "@platformatic/create-platformatic-auto": "1.49.1"
+    "@platformatic/config": "1.50.0",
+    "@platformatic/generators": "1.50.0",
+    "@platformatic/authenticate": "1.50.0",
+    "@platformatic/utils": "1.50.0"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
-    "borp": "^0.15.0",
+    "borp": "^0.16.0",
     "c8": "^10.0.0",
     "cross-env": "^7.0.3",
     "dotenv": "^16.4.5",
@@ -50,12 +52,14 @@
     "standard": "^17.1.0",
     "typescript": "~5.5.0",
     "yaml": "^2.4.1",
-    "@platformatic/db": "1.49.1",
-    "@platformatic/service": "1.49.1"
+    "@platformatic/composer": "1.50.0",
+    "@platformatic/db": "1.50.0",
+    "@platformatic/runtime": "1.50.0",
+    "@platformatic/service": "1.50.0"
   },
   "scripts": {
-    "test:cli": "borp --pattern \"test/cli/*.test.mjs\" --timeout 120000 --concurrency=1",
-    "test:unit": "pnpm run lint && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" borp --coverage --pattern \"test/unit/*.test.mjs\" --timeout 120000",
+    "test:cli": "borp --pattern \"test/cli/*test.mjs\" --timeout 120000 --concurrency=1",
+    "test:unit": "pnpm run lint && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" borp --pattern \"test/unit/*test.mjs\" --timeout 120000 --concurrency=1",
     "test": "npm run test:unit && npm run test:cli",
     "lint": "standard | snazzy"
   }

package/src/colors.mjs

@@ -0,0 +1,4 @@
+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/create-git-repository.mjs

@@ -0,0 +1,108 @@
+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

@@ -0,0 +1,317 @@
+import { say } from './say.mjs'
+import path, { basename, join } from 'node:path'
+import inquirer from 'inquirer'
+import generateName from 'boring-name-generator'
+import { getUsername, getVersion, minimumSupportedNodeVersions, isCurrentVersionSupported, safeMkdir } from './utils.mjs'
+import { createGitRepository } from './create-git-repository.mjs'
+import { getPkgManager } from '@platformatic/utils'
+import { StackableGenerator } from '@platformatic/generators'
+import { getUserApiKey } from '@platformatic/authenticate'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { execa } from 'execa'
+import parseArgs from 'minimist'
+import ora from 'ora'
+import { pathToFileURL } from 'node:url'
+import { writeFile } from 'node:fs/promises'
+import { request } from 'undici'
+import { setTimeout } from 'node:timers/promises'
+import resolve from 'resolve'
+
+const MARKETPLACE_HOST = 'https://marketplace.platformatic.dev'
+
+export async function fetchStackables (marketplaceHost, userApiKey) {
+  marketplaceHost = marketplaceHost || MARKETPLACE_HOST
+
+  const stackablesRequest = request(marketplaceHost + '/templates', {
+    method: 'GET',
+    headers: {
+      'x-platformatic-user-api-key': userApiKey
+    }
+  })
+  const stackablesRequestTimeout = setTimeout(5000, new Error('Request timed out'))
+
+  try {
+    const { statusCode, body } = await Promise.race([
+      stackablesRequest,
+      stackablesRequestTimeout
+    ])
+    if (statusCode === 401 && userApiKey) {
+      return fetchStackables(marketplaceHost)
+    }
+    if (statusCode === 200) {
+      return (await body.json()).map(stackable => stackable.name)
+    }
+  } catch (err) {}
+
+  return ['@platformatic/composer', '@platformatic/db', '@platformatic/service']
+}
+
+export async function chooseStackable (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
+  })
+
+  return options.type
+}
+
+async function importOrLocal ({ pkgManager, name, projectDir, pkg }) {
+  try {
+    return await import(pkg)
+  } catch (err) {
+    try {
+      const fileToImport = resolve.sync(pkg, { basedir: projectDir })
+      return await import(pathToFileURL(fileToImport))
+    } catch { }
+
+    const spinner = ora(`Installing ${pkg}...`).start()
+    await execa(pkgManager, ['install', pkg], { cwd: projectDir })
+    spinner.succeed()
+
+    const fileToImport = resolve.sync(pkg, { basedir: projectDir })
+    return await import(pathToFileURL(fileToImport))
+  }
+}
+
+export const createPlatformatic = async (argv) => {
+  const args = parseArgs(argv, {
+    default: {
+      install: true
+    },
+    boolean: ['install'],
+    string: ['global-config', 'marketplace-host']
+  })
+
+  const username = await getUsername()
+  const version = await getVersion()
+  const greeting = username ? `Hello ${username},` : 'Hello,'
+  await say(`${greeting} welcome to ${version ? `Platformatic ${version}!` : 'Platformatic!'}`)
+
+  const currentVersion = process.versions.node
+  const supported = isCurrentVersionSupported(currentVersion)
+  if (!supported) {
+    const supportedVersions = minimumSupportedNodeVersions.join(' or >= ')
+    await say(`Platformatic is not supported on Node.js v${currentVersion}.`)
+    await say(`Please use one of the following Node.js versions >= ${supportedVersions}.`)
+  }
+
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+
+  const pkgManager = getPkgManager()
+
+  const { projectType } = await inquirer.prompt({
+    type: 'list',
+    name: 'projectType',
+    message: 'What kind of project do you want to create?',
+    default: 'application',
+    choices: [
+      { name: 'Application', value: 'application' },
+      { name: 'Stackable', value: 'stackable' }
+    ]
+  })
+
+  if (projectType === 'application') {
+    await createApplication(args, logger, pkgManager)
+  } else {
+    await createStackable(args, logger, pkgManager)
+  }
+}
+
+async function createApplication (args, logger, pkgManager) {
+  const optionsDir = await inquirer.prompt({
+    type: 'input',
+    name: 'dir',
+    message: 'Where would you like to create your project?',
+    default: 'platformatic'
+  })
+
+  const projectDir = path.resolve(process.cwd(), optionsDir.dir)
+  const projectName = basename(projectDir)
+
+  await safeMkdir(projectDir)
+
+  const runtime = await importOrLocal({
+    pkgManager,
+    name: projectName,
+    projectDir,
+    pkg: '@platformatic/runtime'
+  })
+
+  const generator = new runtime.Generator({
+    logger,
+    name: projectName,
+    inquirer
+  })
+  generator.setConfig({
+    ...generator.config,
+    targetDirectory: projectDir
+  })
+
+  await generator.populateFromExistingConfig()
+  if (generator.existingConfig) {
+    await say('Using existing configuration')
+  }
+
+  const globalConfigPath = args['global-config']
+  const userApiKey = await getUserApiKey(globalConfigPath).catch(() => {})
+  const stackables = await fetchStackables(args['marketplace-host'], userApiKey)
+
+  const names = []
+
+  while (true) {
+    const stackableName = await chooseStackable(stackables)
+    // await say(`Creating a ${stackable} project in ${projectDir}...`)
+
+    const stackable = await importOrLocal({
+      pkgManager,
+      name: projectName,
+      projectDir,
+      pkg: stackableName
+    })
+
+    const { serviceName } = await inquirer.prompt({
+      type: 'input',
+      name: 'serviceName',
+      message: 'What is the name of the service?',
+      default: generateName().dashed,
+      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 = new stackable.Generator({
+      logger,
+      inquirer
+    })
+
+    stackableGenerator.setConfig({
+      ...stackableGenerator.config,
+      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 = ''
+
+  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]
+  }
+
+  generator.setEntryPoint(entrypoint)
+
+  await generator.ask()
+  await generator.prepare()
+  await generator.writeFiles()
+
+  // Create project here
+
+  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 (pkgManager === 'pnpm') {
+    // add pnpm-workspace.yaml file if needed
+    const content = `packages:
+# all packages in direct subdirs of packages/
+- 'services/*'`
+    await (writeFile(join(projectDir, 'pnpm-workspace.yaml'), content))
+  }
+
+  if (args.install) {
+    const spinner = ora('Installing dependencies...').start()
+    await execa(pkgManager, ['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.')
+}
+
+async function createStackable (args, logger, pkgManager) {
+  logger.info('Creating a stackable project...')
+
+  const generator = new StackableGenerator({ logger, inquirer })
+  await generator.ask()
+  await generator.prepare()
+  await generator.writeFiles()
+
+  const projectDir = path.resolve(process.cwd(), generator.config.targetDirectory)
+
+  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 (args.install) {
+    const spinner = ora('Installing dependencies...').start()
+    await execa(pkgManager, ['install'], { cwd: projectDir })
+    spinner.succeed()
+  }
+
+  await generator.postInstallActions()
+  logger.info('Stackable created successfully! Run `npm run create` to create an application.')
+}

package/src/say.mjs

@@ -0,0 +1,20 @@
+import logUpdate from 'log-update'
+import { pltGreen } from './colors.mjs'
+import { sleep, randomBetween } from './utils.mjs'
+
+export const say = async (messages) => {
+  const _messages = Array.isArray(messages) ? messages : [messages]
+
+  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()
+}

package/src/utils.mjs

@@ -1,5 +1,16 @@
-import { access, mkdir } from 'fs/promises'
-import { resolve } from 'path'
+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))
 
 export async function isFileAccessible (filename, directory) {
   try {
@@ -10,6 +21,123 @@ 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/test/cli/README.md

@@ -0,0 +1,8 @@
+To have this test working, you need to link 'platformatic' globally with:
+
+```bash 
+# in platformatic root
+cd packages/cli
+pnpm link --global
+```
+The reason is that the type generation is done expecting the 'platformatic' command to be in the cli, see: https://github.com/platformatic/platformatic/blob/main/packages/create-platformatic/src/service/create-service-cli.mjs#L120