create-platformatic 0.11.0

package/src/db/create-db.mjs

@@ -0,0 +1,200 @@
+import { writeFile, mkdir } from 'fs/promises'
+import { join, relative, resolve } from 'path'
+import { findDBConfigFile, isFileAccessible } from '../utils.mjs'
+
+const connectionStrings = {
+  postgres: 'postgres://postgres:postgres@localhost:5432/postgres',
+  sqlite: 'sqlite://./db.sqlite',
+  mysql: 'mysql://root@localhost:3306/graph',
+  mysql8: 'mysql://root@localhost:3308/graph',
+  mariadb: 'mysql://root@localhost:3307/graph'
+}
+
+const moviesMigrationDo = `
+-- Add SQL in this file to create the database tables for your API
+CREATE TABLE IF NOT EXISTS movies (
+  id INTEGER PRIMARY KEY,
+  title TEXT NOT NULL
+);
+`
+
+const moviesMigrationUndo = `
+-- Add SQL in this file to drop the database tables 
+DROP TABLE movies;
+`
+
+function getTsConfig (outDir) {
+  return {
+    compilerOptions: {
+      module: 'commonjs',
+      esModuleInterop: true,
+      target: 'es6',
+      sourceMap: true,
+      pretty: true,
+      noEmitOnError: true,
+      outDir
+    },
+    watchOptions: {
+      watchFile: 'fixedPollingInterval',
+      watchDirectory: 'fixedPollingInterval',
+      fallbackPolling: 'dynamicPriority',
+      synchronousWatchDirectory: true,
+      excludeDirectories: ['**/node_modules', outDir]
+    }
+  }
+}
+
+const getPluginName = (isTypescript) => isTypescript === true ? 'plugin.ts' : 'plugin.js'
+const TS_OUT_DIR = 'dist'
+
+function generateConfig (migrations, plugin, types, typescript) {
+  const config = {
+    $schema: './platformatic.db.schema.json',
+    server: {
+      hostname: '{PLT_SERVER_HOSTNAME}',
+      port: '{PORT}',
+      logger: {
+        level: '{PLT_SERVER_LOGGER_LEVEL}'
+      }
+    },
+    core: {
+      connectionString: '{DATABASE_URL}',
+      graphql: true,
+      openapi: true
+    },
+    migrations: { dir: migrations }
+  }
+
+  if (plugin === true) {
+    config.plugin = {
+      path: getPluginName(typescript)
+    }
+  }
+
+  if (types === true) {
+    config.types = {
+      autogenerate: true
+    }
+  }
+
+  if (typescript === true) {
+    config.plugin.typescript = {
+      outDir: TS_OUT_DIR
+    }
+  }
+
+  return config
+}
+
+function generateEnv (hostname, port, database) {
+  const connectionString = connectionStrings[database]
+  const env = `\
+PLT_SERVER_HOSTNAME=${hostname}
+PORT=${port}
+PLT_SERVER_LOGGER_LEVEL=info
+DATABASE_URL=${connectionString}
+`
+  return env
+}
+
+const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
+/// <reference path="./global.d.ts" />
+'use strict'
+
+/** @param {import('fastify').FastifyInstance} app */
+module.exports = async function (app) {}
+`
+
+const TS_PLUGIN_WITH_TYPES_SUPPORT = `\
+/// <reference path="./global.d.ts" />
+import { FastifyInstance } from 'fastify'
+
+export default async function (app: FastifyInstance) {}
+`
+
+async function generatePluginWithTypesSupport (logger, currentDir, isTypescript) {
+  const pluginPath = resolve(currentDir, getPluginName(isTypescript))
+
+  const isPluginExists = await isFileAccessible(pluginPath)
+  if (isPluginExists) {
+    logger.info(`Plugin file ${pluginPath} found, skipping creation of plugin file.`)
+    return
+  }
+
+  const pluginTemplate = isTypescript
+    ? TS_PLUGIN_WITH_TYPES_SUPPORT
+    : JS_PLUGIN_WITH_TYPES_SUPPORT
+
+  await writeFile(pluginPath, pluginTemplate)
+  logger.info(`Plugin file created at ${relative(currentDir, pluginPath)}`)
+}
+
+async function createDB ({ hostname, database = 'sqlite', port, migrations = 'migrations', plugin = true, types = true, typescript = false }, logger, currentDir) {
+  const createMigrations = !!migrations // If we don't define a migrations folder, we don't create it
+  const accessibleConfigFilename = await findDBConfigFile(currentDir)
+  if (accessibleConfigFilename === undefined) {
+    const config = generateConfig(migrations, plugin, types, typescript)
+    await writeFile(join(currentDir, 'platformatic.db.json'), JSON.stringify(config, null, 2))
+    logger.info('Configuration file platformatic.db.json successfully created.')
+
+    const env = generateEnv(hostname, port, database)
+    await writeFile(join(currentDir, '.env'), env)
+    await writeFile(join(currentDir, '.env.sample'), env)
+    logger.info('Environment file .env successfully created.')
+  } else {
+    logger.info(`Configuration file ${accessibleConfigFilename} found, skipping creation of configuration file.`)
+  }
+
+  const migrationsFolderName = migrations
+  if (createMigrations) {
+    const isMigrationFolderExists = await isFileAccessible(migrationsFolderName, currentDir)
+    if (!isMigrationFolderExists) {
+      await mkdir(join(currentDir, migrationsFolderName))
+      logger.info(`Migrations folder ${migrationsFolderName} successfully created.`)
+    } else {
+      logger.info(`Migrations folder ${migrationsFolderName} found, skipping creation of migrations folder.`)
+    }
+  }
+
+  const migrationFileNameDo = '001.do.sql'
+  const migrationFileNameUndo = '001.undo.sql'
+  const migrationFilePathDo = join(currentDir, migrationsFolderName, migrationFileNameDo)
+  const migrationFilePathUndo = join(currentDir, migrationsFolderName, migrationFileNameUndo)
+  const isMigrationFileDoExists = await isFileAccessible(migrationFilePathDo)
+  const isMigrationFileUndoExists = await isFileAccessible(migrationFilePathUndo)
+  if (!isMigrationFileDoExists && createMigrations) {
+    await writeFile(migrationFilePathDo, moviesMigrationDo)
+    logger.info(`Migration file ${migrationFileNameDo} successfully created.`)
+    if (!isMigrationFileUndoExists) {
+      await writeFile(migrationFilePathUndo, moviesMigrationUndo)
+      logger.info(`Migration file ${migrationFileNameUndo} successfully created.`)
+    }
+  } else {
+    logger.info(`Migration file ${migrationFileNameDo} found, skipping creation of migration file.`)
+  }
+
+  if (typescript === true) {
+    const tsConfigFileName = join(currentDir, 'tsconfig.json')
+    const isTsConfigExists = await isFileAccessible(tsConfigFileName)
+    if (!isTsConfigExists) {
+      const tsConfig = getTsConfig(TS_OUT_DIR)
+      await writeFile(tsConfigFileName, JSON.stringify(tsConfig, null, 2))
+      logger.info(`Typescript configuration file ${tsConfigFileName} successfully created.`)
+    } else {
+      logger.info(`Typescript configuration file ${tsConfigFileName} found, skipping creation of typescript configuration file.`)
+    }
+  }
+
+  if (plugin) {
+    await generatePluginWithTypesSupport(logger, currentDir, typescript)
+  }
+
+  return {
+    DATABASE_URL: connectionStrings[database],
+    PLT_SERVER_LOGGER_LEVEL: 'info',
+    PORT: port,
+    PLT_SERVER_HOSTNAME: hostname
+  }
+}
+
+export default createDB

package/src/get-pkg-manager.mjs

@@ -0,0 +1,11 @@
+
+export const getPkgManager = () => {
+  const userAgent = process.env.npm_config_user_agent
+  if (!userAgent) {
+    return 'npm'
+  }
+  const pmSpec = userAgent.split(' ')[0]
+  const separatorPos = pmSpec.lastIndexOf('/')
+  const name = pmSpec.substring(0, separatorPos)
+  return name || 'npm'
+}

package/src/ghaction.mjs

@@ -0,0 +1,68 @@
+import mkdirp from 'mkdirp'
+import { join } from 'path'
+import inquirer from 'inquirer'
+import { isFileAccessible } from './utils.mjs'
+import { writeFile } from 'fs/promises'
+
+export const ghTemplate = (env, type) => {
+  const envAsStr = Object.keys(env).reduce((acc, key) => {
+    acc += `          ${key}: ${env[key]} \n`
+    return acc
+  }, '')
+
+  return `name: Deploy Platformatic application to the cloud
+on:
+  pull_request:
+    paths-ignore:
+      - 'docs/**'
+      - '**.md'
+
+jobs:
+  build_and_deploy:
+    runs-on: ubuntu-latest
+    steps:
+      - name: Checkout application project repository
+        uses: actions/checkout@v3
+      - name: npm install --omit=dev
+        run: npm install --omit=dev
+      - name: Deploy project
+        uses: platformatic/onestep@latest
+        with:
+          github_token: \${{ secrets.GITHUB_TOKEN }}
+          platformatic_api_key: \${{ secrets.PLATFORMATIC_API_KEY }}
+          platformatic_config_path: ./platformatic.${type}.json
+        env:
+${envAsStr}
+`
+}
+
+export const createGHAction = async (logger, env, type, projectDir) => {
+  const ghActionFileName = 'platformatic-deploy.yml'
+  const ghActionFilePath = join(projectDir, '.github', 'workflows', ghActionFileName)
+  const isGithubActionExists = await isFileAccessible(ghActionFilePath)
+  if (!isGithubActionExists) {
+    await mkdirp(join(projectDir, '.github', 'workflows'))
+    await writeFile(ghActionFilePath, ghTemplate(env, type))
+    logger.info('Github action successfully created, please add PLATFORMATIC_API_KEY as repository secret.')
+    const isGitDir = await isFileAccessible('.git', projectDir)
+    if (!isGitDir) {
+      logger.warn('No git repository found. The Github action won\'t be triggered.')
+    }
+  } else {
+    logger.info(`Github action file ${ghActionFilePath} found, skipping creation of github action file.`)
+  }
+}
+
+/* c8 ignore next 12 */
+export const askCreateGHAction = async (logger, env, type, projectDir = process.cwd()) => {
+  const { githubAction } = await inquirer.prompt([{
+    type: 'list',
+    name: 'githubAction',
+    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 }]
+  }])
+  if (githubAction) {
+    await createGHAction(logger, env, type, projectDir)
+  }
+}

package/src/index.mjs

@@ -0,0 +1,51 @@
+import { say } from './say.mjs'
+import helpMe from 'help-me'
+import { join } from 'desm'
+import inquirer from 'inquirer'
+import createPlatformaticDB from './db/create-db-cli.mjs'
+import createPlatformaticService from './service/create-service-cli.mjs'
+import commist from 'commist'
+import { getUsername, getVersion } from './utils.mjs'
+
+const createPlatformatic = async (argv) => {
+  const help = helpMe({
+    dir: join(import.meta.url, '..', 'help'),
+    ext: '.txt'
+  })
+
+  const program = commist({ maxDistance: 4 })
+
+  program.register('help', help.toStdout)
+  program.register('db help', help.toStdout.bind(null, ['db']))
+  program.register('service help', help.toStdout.bind(null, ['service']))
+  program.register('db', createPlatformaticDB)
+  program.register('service', createPlatformaticService)
+
+  const result = program.parse(argv)
+
+  if (result) {
+    const username = await getUsername()
+    const version = await getVersion()
+    const greeting = username ? `Hello, ${username}` : 'Hello,'
+    await say(`${greeting} welcome to ${version ? `Platformatic ${version}!` : 'Platformatic!'}`)
+    await say('Let\'s start by creating a new project.')
+
+    const options = await inquirer.prompt({
+      type: 'list',
+      name: 'type',
+      message: 'Which kind of project do you want to create?',
+      default: 'db',
+      choices: [{ name: 'DB', value: 'db' }, { name: 'Service', value: 'service' }]
+    })
+
+    if (options.type === 'db') {
+      await createPlatformaticDB(argv)
+    } else if (options.type === 'service') {
+      await createPlatformaticService(argv)
+    }
+
+    await say('\nAll done! Please open the project directory and check the README.')
+  }
+}
+
+export default createPlatformatic

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/service/README.md

@@ -0,0 +1,31 @@
+# Platformatic Service API
+
+This is a generated [Platformatic DB](https://oss.platformatic.dev/docs/reference/service/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/) >= v16.17.0 or >= v18.8.0
+
+## Setup 
+
+Install dependencies:
+
+```bash
+npm install
+```
+
+## Usage
+
+Run the API with:
+
+```bash
+npm start
+```
+
+### Explore
+- ⚡ The Platformatic DB server is running at http://localhost:3042/
+- 📔 View the REST API's Swagger documentation at http://localhost:3042/documentation/
+- 🔍 Try out the GraphiQL web UI at http://localhost:3042/graphiql
+
+

package/src/service/create-service-cli.mjs

@@ -0,0 +1,88 @@
+
+import { getVersion, getDependencyVersion, isFileAccessible } from '../utils.mjs'
+import { createPackageJson } from '../create-package-json.mjs'
+import { createGitignore } from '../create-gitignore.mjs'
+import { getPkgManager } from '../get-pkg-manager.mjs'
+import parseArgs from 'minimist'
+import { join } from 'path'
+import inquirer from 'inquirer'
+import { readFile, writeFile } from 'fs/promises'
+import pino from 'pino'
+import pretty from 'pino-pretty'
+import { execa } from 'execa'
+import ora from 'ora'
+import createService from './create-service.mjs'
+import askProjectDir from '../ask-project-dir.mjs'
+import { askCreateGHAction } from '../ghaction.mjs'
+import mkdirp from 'mkdirp'
+
+export const createReadme = async (logger, dir = '.') => {
+  const readmeFileName = join(dir, 'README.md')
+  const isReadmeExists = await isFileAccessible(readmeFileName)
+  if (!isReadmeExists) {
+    const readmeFile = new URL('README.md', import.meta.url)
+    const readme = await readFile(readmeFile, 'utf-8')
+    await writeFile(readmeFileName, readme)
+    logger.debug(`${readmeFileName} successfully created.`)
+  } else {
+    logger.debug(`${readmeFileName} found, skipping creation of README.md file.`)
+  }
+}
+
+const createPlatformaticService = async (_args) => {
+  const logger = pino(pretty({
+    translateTime: 'SYS:HH:MM:ss',
+    ignore: 'hostname,pid'
+  }))
+
+  const args = parseArgs(_args, {
+    default: {
+      hostname: '127.0.0.1',
+      port: 3042
+    },
+    alias: {
+      h: 'hostname',
+      p: 'port'
+    }
+  })
+
+  const version = await getVersion()
+  const pkgManager = getPkgManager()
+
+  const projectDir = await askProjectDir(logger, '.')
+
+  // Create the project directory
+  await mkdirp(projectDir)
+
+  const params = {
+    hostname: args.hostname,
+    port: args.port
+  }
+
+  const env = await createService(params, logger, projectDir)
+
+  const fastifyVersion = await getDependencyVersion('fastify')
+
+  // Create the package.json, .gitignore, readme
+  await createPackageJson('service', version, fastifyVersion, logger, projectDir)
+  await createGitignore(logger, projectDir)
+  await createReadme(logger, projectDir)
+
+  const { runPackageManagerInstall } = await inquirer.prompt([{
+    type: 'list',
+    name: 'runPackageManagerInstall',
+    message: `Do you want to run ${pkgManager} install?`,
+    default: true,
+    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
+  }])
+
+  if (runPackageManagerInstall) {
+    const spinner = ora('Installing dependencies...').start()
+    await execa(pkgManager, ['install'], { cwd: projectDir })
+    spinner.succeed('...done!')
+  }
+
+  await askCreateGHAction(logger, env, 'service')
+}
+
+export default createPlatformaticService

package/src/service/create-service.mjs

@@ -0,0 +1,94 @@
+import { writeFile, mkdir } from 'fs/promises'
+import { join } from 'path'
+import { findServiceConfigFile, isFileAccessible } from '../utils.mjs'
+
+function generateConfig () {
+  const plugin = [
+    './plugins',
+    './routes'
+  ]
+
+  const config = {
+    server: {
+      hostname: '{PLT_SERVER_HOSTNAME}',
+      port: '{PORT}',
+      logger: {
+        level: '{PLT_SERVER_LOGGER_LEVEL}'
+      }
+    },
+    plugin
+  }
+
+  return config
+}
+
+function generateEnv (hostname, port) {
+  const env = `\
+PLT_SERVER_HOSTNAME=${hostname}
+PORT=${port}
+PLT_SERVER_LOGGER_LEVEL=info
+`
+  return env
+}
+
+const JS_PLUGIN_WITH_TYPES_SUPPORT = `\
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.decorate('example', 'foobar')
+}
+module.exports[Symbol.for('skip-override')] = true
+`
+
+const ROUTES_WITH_TYPES_SUPPORT = `\
+'use strict'
+/** @param {import('fastify').FastifyInstance} fastify */
+module.exports = async function (fastify, opts) {
+  fastify.get('/', async (request, reply) => {
+    return { hello: fastify.example }
+  })
+}
+`
+
+async function createService ({ hostname, port }, logger, currentDir = process.cwd()) {
+  const accessibleConfigFilename = await findServiceConfigFile(currentDir)
+
+  if (accessibleConfigFilename === undefined) {
+    const config = generateConfig()
+    await writeFile(join(currentDir, 'platformatic.service.json'), JSON.stringify(config, null, 2))
+    logger.info('Configuration file platformatic.service.json successfully created.')
+
+    const env = generateEnv(hostname, port)
+    await writeFile(join(currentDir, '.env'), env)
+    await writeFile(join(currentDir, '.env.sample'), env)
+    logger.info('Environment file .env successfully created.')
+  } else {
+    logger.info(`Configuration file ${accessibleConfigFilename} found, skipping creation of configuration file.`)
+  }
+
+  const pluginFolderExists = await isFileAccessible('plugins', currentDir)
+  if (!pluginFolderExists) {
+    await mkdir(join(currentDir, 'plugins'))
+    await writeFile(join(currentDir, 'plugins', 'example.js'), JS_PLUGIN_WITH_TYPES_SUPPORT)
+    logger.info('Plugins folder "plugins" successfully created.')
+  } else {
+    logger.info('Plugins folder "plugins" found, skipping creation of plugins folder.')
+  }
+
+  const routeFolderExists = await isFileAccessible('routes', currentDir)
+  if (!routeFolderExists) {
+    await mkdir(join(currentDir, 'routes'))
+    await writeFile(join(currentDir, 'routes', 'root.js'), ROUTES_WITH_TYPES_SUPPORT)
+    logger.info('Routes folder "routes" successfully created.')
+  } else {
+    logger.info('Routes folder "routes" found, skipping creation of routes folder.')
+  }
+
+  return {
+    PLT_SERVER_LOGGER_LEVEL: 'info',
+    PORT: port,
+    PLT_SERVER_HOSTNAME: hostname
+  }
+}
+
+export default createService

package/src/utils.mjs

@@ -0,0 +1,95 @@
+import { execa } from 'execa'
+import { request } from 'undici'
+import { access, constants, readFile } from 'fs/promises'
+import { resolve, join, dirname } from 'path'
+import { createRequire } from 'module'
+
+export const sleep = ms => new Promise((resolve) => setTimeout(resolve, ms))
+export const randomBetween = (min, max) => Math.floor(Math.random() * (max - min + 1) + min)
+
+export async function isFileAccessible (filename, directory) {
+  try {
+    const filePath = directory ? resolve(directory, filename) : filename
+    await access(filePath)
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+export const getUsername = async () => {
+  const { stdout } = await execa('git', ['config', 'user.name'])
+  if (stdout?.trim()) {
+    return stdout.trim()
+  }
+  {
+    const { stdout } = await execa('whoami')
+    if (stdout?.trim()) {
+      return stdout.trim()
+    }
+  }
+  return null
+}
+
+export const getVersion = async () => {
+  try {
+    const { body, statusCode } = await request('https://registry.npmjs.org/platformatic/latest')
+    if (statusCode !== 200) {
+      return null
+    }
+    const { version } = await body.json()
+    return version
+  } catch (err) {
+    return null
+  }
+}
+
+export async function isDirectoryWriteable (directory) {
+  try {
+    await access(directory, constants.R_OK | constants.W_OK)
+    return true
+  } catch (err) {
+    return false
+  }
+}
+
+export const validatePath = async projectPath => {
+  // if the folder exists, is OK:
+  const projectDir = resolve(projectPath)
+  const canAccess = await isDirectoryWriteable(projectDir)
+  if (canAccess) {
+    return true
+  }
+  // if the folder does not exist, check if the parent folder exists:
+  const parentDir = dirname(projectDir)
+  const canAccessParent = await isDirectoryWriteable(parentDir)
+  if (canAccessParent) {
+    return true
+  }
+  return false
+}
+
+const findConfigFile = async (directory, type) => {
+  const configFileNames = [
+    `platformatic.${type}.json`,
+    `platformatic.${type}.json5`,
+    `platformatic.${type}.yaml`,
+    `platformatic.${type}.yml`,
+    `platformatic.${type}.toml`,
+    `platformatic.${type}.tml`
+  ]
+  const configFilesAccessibility = await Promise.all(configFileNames.map((fileName) => isFileAccessible(fileName, directory)))
+  const accessibleConfigFilename = configFileNames.find((value, index) => configFilesAccessibility[index])
+  return accessibleConfigFilename
+}
+
+export const findDBConfigFile = async (directory) => (findConfigFile(directory, 'db'))
+export const findServiceConfigFile = async (directory) => (findConfigFile(directory, 'service'))
+
+export const getDependencyVersion = async (dependencyName) => {
+  const require = createRequire(import.meta.url)
+  const pathToPackageJson = join(dirname(require.resolve(dependencyName)), 'package.json')
+  const packageJsonFile = await readFile(pathToPackageJson, 'utf-8')
+  const packageJson = JSON.parse(packageJsonFile)
+  return packageJson.version
+}