create-platformatic 3.4.1 → 3.5.0

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 { checkNodeVersionForApplications } from '@platformatic/foundation'
+import { createPlatformatic } from 'create-wattpm'
+import parseArgs from 'minimist'
+import { readFile } from 'node:fs/promises'
+import { join } from 'node:path'
+
+checkNodeVersionForApplications()
+
+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,65 +1,33 @@
 {
   "name": "create-platformatic",
-  "version": "3.4.1",
+  "version": "3.5.0",
   "description": "Create platformatic application interactive tool",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/platformatic/platformatic.git"
   },
-  "exports": {
-    ".": "./create-platformatic.mjs"
-  },
   "bin": {
-    "create-platformatic": "./create-platformatic.mjs"
+    "create-platformatic": "./bin/cli.js"
   },
+  "type": "module",
   "license": "Apache-2.0",
-  "author": "Matteo Collina <hello@matteocollina.com>",
+  "author": "Platformatic Inc. <oss@platformatic.dev> (https://platformatic.dev)",
   "dependencies": {
-    "boring-name-generator": "^1.0.3",
-    "chalk": "^5.3.0",
-    "columnify": "^1.6.0",
-    "commist": "^3.2.0",
-    "desm": "^1.3.1",
-    "es-main": "^1.3.0",
-    "execa": "^8.0.1",
-    "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",
-    "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": "3.4.1",
-    "@platformatic/generators": "3.4.1",
-    "@platformatic/utils": "3.4.1"
+    "@platformatic/foundation": "3.5.0",
+    "create-wattpm": "3.5.0"
   },
   "devDependencies": {
-    "@types/node": "^22.5.0",
-    "ajv": "^8.12.0",
-    "borp": "^0.17.0",
-    "c8": "^10.0.0",
-    "cross-env": "^7.0.3",
-    "dotenv": "^16.4.5",
+    "cleaner-spec-reporter": "^0.5.0",
     "eslint": "9",
-    "esmock": "^2.6.4",
-    "fastify": "^5.0.0",
-    "neostandard": "^0.11.1",
-    "typescript": "~5.6.0",
-    "yaml": "^2.4.1",
-    "@platformatic/composer": "3.4.1",
-    "@platformatic/runtime": "3.4.1",
-    "@platformatic/db": "3.4.1",
-    "@platformatic/service": "3.4.1"
+    "import-in-the-middle": "^1.14.2",
+    "neostandard": "^0.12.0"
+  },
+  "engines": {
+    "node": ">=22.19.0"
   },
   "scripts": {
-    "test:cli": "borp --pattern \"test/cli/*test.mjs\" --timeout=180000 --concurrency=1",
-    "test:unit": "pnpm run lint && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" borp --pattern \"test/unit/*test.mjs\" --timeout=180000 --concurrency=1",
-    "test": "npm run test:unit && npm run test:cli",
-    "lint": "eslint"
+    "test": "node --test --test-reporter=cleaner-spec-reporter --test-concurrency=1 --test-timeout=2000000 test/*.test.js test/**/*.test.js",
+    "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/create-platformatic.mjs

@@ -1,26 +0,0 @@
-#!/usr/bin/env node
-import { checkNodeVersionForServices } from '@platformatic/utils'
-import { join } from 'desm'
-import isMain from 'es-main'
-import { readFile } from 'fs/promises'
-import parseArgs from 'minimist'
-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.url, 'package.json'), 'utf8')).version)
-    process.exit(0)
-  }
-  await createPlatformatic(_args)
-}
-
-export { createPlatformatic }

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/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,282 +0,0 @@
-import { createDirectory, getPkgManager } from '@platformatic/utils'
-import generateName from 'boring-name-generator'
-import { execa } from 'execa'
-import inquirer from 'inquirer'
-import parseArgs from 'minimist'
-import { writeFile, readFile } from 'node:fs/promises'
-import path, { basename, join } from 'node:path'
-import { setTimeout } from 'node:timers/promises'
-import { pathToFileURL } from 'node:url'
-import ora from 'ora'
-import pino from 'pino'
-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, isCurrentVersionSupported, minimumSupportedNodeVersions } from './utils.mjs'
-
-const MARKETPLACE_HOST = 'https://marketplace.platformatic.dev'
-const defaultStackables = ['@platformatic/composer', '@platformatic/db', '@platformatic/service']
-
-export async function fetchStackables (marketplaceHost) {
-  // Skip the remote network request if we are running tests
-  if (process.env.MARKETPLACE_TEST) {
-    return [...defaultStackables]
-  }
-
-  marketplaceHost = marketplaceHost || MARKETPLACE_HOST
-
-  const stackablesRequest = request(marketplaceHost + '/templates')
-  const stackablesRequestTimeout = setTimeout(5000, new Error('Request timed out'))
-
-  try {
-    const { statusCode, body } = await Promise.race([stackablesRequest, stackablesRequestTimeout])
-    if (statusCode === 200) {
-      return (await body.json()).map(stackable => stackable.name)
-    }
-  } catch (err) {}
-
-  return [...defaultStackables]
-}
-
-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 {}
-
-    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}...`).start()
-    await execa(pkgManager, ['install', pkg + version], { 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()
-  await createApplication(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 createDirectory(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 stackables = await fetchStackables(args['marketplace-host'])
-
-  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.')
-}

package/src/say.mjs

@@ -1,20 +0,0 @@
-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,140 +0,0 @@
-import * as desm from 'desm'
-import { execa } from 'execa'
-import { access, constants, readFile } from 'fs/promises'
-import { createRequire } from 'module'
-import { dirname, join, resolve } from 'path'
-import semver from 'semver'
-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 {
-    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(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
-}