create-platformatic 1.17.0 → 1.19.0

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

@@ -1,263 +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 which from 'which'
-import pino from 'pino'
-import pretty from 'pino-pretty'
-import { execa } from 'execa'
-import ora from 'ora'
-import { getConnectionString, createDB } from './create-db.mjs'
-import askDir from '../ask-dir.mjs'
-import { getUseTypescript, getPort, getInitGitRepository } from '../cli-options.mjs'
-import { createReadme } from '../create-readme.mjs'
-import { join } from 'node:path'
-
-const databases = [{
-  value: 'sqlite',
-  name: 'SQLite'
-}, {
-  value: 'postgres',
-  name: 'PostgreSQL'
-}, {
-  value: 'mysql',
-  name: 'MySQL'
-}, {
-  value: 'mariadb',
-  name: 'MariaDB'
-}]
-
-export function parseDBArgs (_args) {
-  return parseArgs(_args, {
-    default: {
-      hostname: '127.0.0.1',
-      database: 'sqlite',
-      migrations: 'migrations',
-      install: true
-    },
-    alias: {
-      h: 'hostname',
-      p: 'port',
-      pl: 'plugin',
-      db: 'database',
-      m: 'migrations',
-      t: 'types',
-      ts: 'typescript'
-    },
-    boolean: ['plugin', 'types', 'typescript', 'install']
-  })
-}
-
-const createPlatformaticDB = async (_args, opts) => {
-  const logger = opts.logger || pino(pretty({
-    translateTime: 'SYS:HH:MM:ss',
-    ignore: 'hostname,pid'
-  }))
-
-  const args = parseDBArgs(_args)
-  const version = await getVersion()
-  const pkgManager = getPkgManager()
-  const projectDir = opts.dir || await askDir(logger, join('.', 'platformatic-db'))
-
-  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)
-
-  const { database } = await inquirer.prompt({
-    type: 'list',
-    name: 'database',
-    message: 'What database do you want to use?',
-    default: args.database,
-    choices: databases
-  })
-
-  let connectionString = getConnectionString(database)
-
-  while (true) {
-    const pickConnectionString = await inquirer.prompt({
-      type: 'expand',
-      name: 'edit',
-      message: `Do you want to use the connection string "${connectionString}"?`,
-      choices: [
-        {
-          key: 'y',
-          name: 'Confirm',
-          value: false
-        },
-        {
-          key: 'e',
-          name: 'Edit',
-          value: true
-        }
-      ]
-    })
-
-    if (pickConnectionString.edit) {
-      const answers = await inquirer.prompt({
-        type: 'editor',
-        name: 'connectionString',
-        message: 'Edit the connection string',
-        default: connectionString
-      })
-      connectionString = answers.connectionString.trim()
-    } else {
-      break
-    }
-  }
-
-  toAsk.push({
-    type: 'list',
-    name: 'defaultMigrations',
-    message: 'Do you want to create default migrations?',
-    default: true,
-    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-  })
-  toAsk.push({
-    type: 'list',
-    name: 'applyMigrations',
-    message: 'Do you want to apply migrations?',
-    default: true,
-    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }],
-    when: (answers) => {
-      return answers.defaultMigrations
-    }
-  })
-
-  if (args.plugin === false) {
-    toAsk.push({
-      type: 'list',
-      name: 'generatePlugin',
-      message: 'Do you want to create a plugin?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    })
-  }
-
-  toAsk.push(getUseTypescript(args.typescript))
-
-  toAsk.push({
-    type: 'list',
-    name: 'staticWorkspaceGitHubAction',
-    message: 'Do you want to create the github action to deploy this application to Platformatic Cloud?',
-    default: true,
-    when: !opts.skipGitHubActions,
-    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,
-    when: !opts.skipGitHubActions,
-    choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-  })
-  if (!opts.skipGitRepository) {
-    toAsk.push(getInitGitRepository())
-  }
-  // Prompt for questions
-  const wizardOptions = await inquirer.prompt(toAsk)
-
-  await safeMkdir(projectDir)
-
-  const generatePlugin = args.plugin || wizardOptions.generatePlugin
-  const useTypescript = args.typescript || wizardOptions.useTypescript
-  const useTypes = args.types || generatePlugin // we set this always to true if we want to generate a plugin
-
-  const params = {
-    isRuntimeContext,
-    hostname: args.hostname,
-    port: wizardOptions.port,
-    database,
-    connectionString,
-    migrations: wizardOptions.defaultMigrations ? args.migrations : '',
-    plugin: generatePlugin,
-    types: useTypes,
-    typescript: useTypescript,
-    staticWorkspaceGitHubAction: wizardOptions.staticWorkspaceGitHubAction,
-    dynamicWorkspaceGitHubAction: wizardOptions.dynamicWorkspaceGitHubAction,
-    runtimeContext: opts.runtimeContext,
-    initGitRepository: wizardOptions.initGitRepository
-  }
-
-  await createDB(params, logger, projectDir, version)
-
-  const fastifyVersion = await getDependencyVersion('fastify')
-
-  const scripts = {
-    migrate: 'platformatic db migrations apply',
-    test: useTypescript ? 'tsc && node --test dist/test/*/*.test.js' : 'node --test test/*/*.test.js'
-  }
-
-  const dependencies = {
-    '@platformatic/db': `^${version}`
-  }
-
-  // Create the package.json, .gitignore, readme
-  await createPackageJson(version, fastifyVersion, logger, projectDir, useTypescript, scripts, dependencies)
-  await createGitignore(logger, projectDir)
-  await createReadme(logger, projectDir, 'db')
-
-  let hasPlatformaticInstalled = false
-  if (args.install && !opts.skipPackageJson) {
-    const spinner = ora('Installing dependencies...').start()
-    await execa(pkgManager, ['install'], { cwd: projectDir })
-    spinner.succeed()
-    hasPlatformaticInstalled = true
-  }
-
-  if (!hasPlatformaticInstalled) {
-    try {
-      const npmLs = JSON.parse(await execa('npm', ['ls', '--json']).toString())
-      hasPlatformaticInstalled = !!npmLs.dependencies.platformatic
-    } catch {
-      // Ignore all errors, this can fail
-    }
-  }
-
-  if (!hasPlatformaticInstalled) {
-    const exe = await which('platformatic', { nothrow: true })
-    hasPlatformaticInstalled = !!exe
-  }
-
-  if (hasPlatformaticInstalled) {
-    // We applied package manager install, so we can:
-    // - run the migrations
-    // - generate types
-    // if we don't generate migrations, we don't ask to apply them (the folder might not exist)
-    let migrationApplied = false
-    if (wizardOptions.defaultMigrations && wizardOptions.applyMigrations) {
-      const spinner = ora('Applying migrations...').start()
-      // We need to apply migrations using the platformatic installed in the project
-      try {
-        await execa(pkgManager, ['exec', 'platformatic', 'db', 'migrations', 'apply'], { cwd: projectDir })
-        spinner.succeed()
-        migrationApplied = true
-      } catch (err) {
-        logger.trace({ err })
-        spinner.fail('Failed applying migrations! Try again by running "platformatic db migrations apply"')
-      }
-    }
-    if (generatePlugin && migrationApplied) {
-      const spinner = ora('Generating types...').start()
-      try {
-        await execa(pkgManager, ['exec', 'platformatic', 'db', 'types'], { cwd: projectDir })
-        spinner.succeed()
-      } catch (err) {
-        logger.trace({ err })
-        spinner.fail('Failed to generate Types. Try again by running "platformatic service types"')
-      }
-    }
-  }
-  // returns metadata that can be used to make some further actions
-  return {
-    typescript: useTypescript
-  }
-}
-
-export default createPlatformaticDB

package/src/db/create-db.mjs

@@ -1,449 +0,0 @@
-import { writeFile, appendFile } from 'fs/promises'
-import { join } from 'path'
-import { addPrefixToEnv, safeMkdir } from '../utils.mjs'
-import { getTsConfig } from '../get-tsconfig.mjs'
-import { generatePlugins } from '../create-plugins.mjs'
-import { createDynamicWorkspaceGHAction, createStaticWorkspaceGHAction } from '../ghaction.mjs'
-import { createGitRepository } from '../create-git-repository.mjs'
-
-const connectionStrings = {
-  postgres: 'postgres://postgres:postgres@127.0.0.1:5432/postgres',
-  sqlite: 'sqlite://./db.sqlite',
-  mysql: 'mysql://root@127.0.0.1:3306/platformatic',
-  mariadb: 'mysql://root@127.0.0.1:3306/platformatic'
-}
-
-const moviesMigrationDo = (database) => {
-  const key = {
-    postgres: 'SERIAL',
-    sqlite: 'INTEGER',
-    mysql: 'INTEGER UNSIGNED AUTO_INCREMENT',
-    mariadb: 'INTEGER UNSIGNED AUTO_INCREMENT'
-  }
-
-  return `
--- Add SQL in this file to create the database tables for your API
-CREATE TABLE IF NOT EXISTS movies (
-  id ${key[database]} PRIMARY KEY,
-  title TEXT NOT NULL
-);
-`
-}
-
-const moviesMigrationUndo = `
--- Add SQL in this file to drop the database tables 
-DROP TABLE movies;
-`
-
-const TS_OUT_DIR = 'dist'
-
-const jsHelperSqlite = {
-  requires: `
-const os = require('node:os')
-const path = require('node:path')
-const fs = require('node:fs/promises')
-
-let counter = 0
-`,
-  pre: `
-  const dbPath = join(os.tmpdir(), 'db-' + process.pid + '-' + counter++ + '.sqlite')
-  const connectionString = 'sqlite://' + dbPath
-`,
-  config: `
-  config.migrations.autoApply = true
-  config.types.autogenerate = false
-  config.db.connectionString = connectionString
-`,
-  post: `
-  t.after(async () => {
-    await fs.unlink(dbPath)
-  })
-`
-}
-
-function jsHelperPostgres (connectionString) {
-  return {
-    // TODO(mcollina): replace sql-mapper
-    requires: `
-const { createConnectionPool } = require('@platformatic/sql-mapper')
-const connectionString = '${connectionString}'
-let counter = 0
-`,
-    pre: `
-  const { db, sql } = await createConnectionPool({
-    log: {
-      debug: () => {},
-      info: () => {},
-      trace: () => {}
-    },
-    connectionString,
-    poolSize: 1
-  })
-
-  const newDB = \`t-\${process.pid}-\${counter++}\`
-  t.diagnostic('Creating database ' + newDB)
-
-  await db.query(sql\`
-    CREATE DATABASE \${sql.ident(newDB)}
-  \`)
-`,
-    config: `
-  config.migrations.autoApply = true
-  config.types.autogenerate = false
-  config.db.connectionString = connectionString.replace(/\\/[a-zA-Z0-9\\-_]+$/, '/' + newDB)
-  config.db.schemalock = false
-`,
-    post: `
-  t.after(async () => {
-    t.diagnostic('Disposing test database ' + newDB)
-    await db.query(sql\`
-      DROP DATABASE \${sql.ident(newDB)}
-    \`)
-    await db.dispose()
-  })
-`
-  }
-}
-
-function jsHelperMySQL (connectionString) {
-  return {
-    // TODO(mcollina): replace sql-mapper
-    requires: `
-const { createConnectionPool } = require('@platformatic/sql-mapper')
-const connectionString = '${connectionString}'
-let counter = 0
-`,
-    pre: `
-  const { db, sql } = await createConnectionPool({
-    log: {
-      debug: () => {},
-      info: () => {},
-      trace: () => {}
-    },
-    connectionString,
-    poolSize: 1
-  })
-
-  const newDB = \`t-\${process.pid}-\${counter++}\`
-  t.diagnostic('Creating database ' + newDB)
-
-  await db.query(sql\`
-    CREATE DATABASE \${sql.ident(newDB)}
-  \`)
-`,
-    config: `
-  config.migrations.autoApply = true
-  config.types.autogenerate = false
-  config.db.connectionString = connectionString.replace(/\\/[a-zA-Z0-9\\-_]+$/, '/' + newDB)
-  config.db.schemalock = false
-`,
-    post: `
-  t.after(async () => {
-    t.diagnostic('Disposing test database ' + newDB)
-    await db.query(sql\`
-      DROP DATABASE \${sql.ident(newDB)}
-    \`)
-    await db.dispose()
-  })
-`
-  }
-}
-
-const moviesTestJS = `\
-'use strict'
-
-const test = require('node:test')
-const assert = require('node:assert')
-const { getServer } = require('../helper')
-
-test('movies', async (t) => {
-  const server = await getServer(t)
-
-  {
-    const res = await server.inject({
-      method: 'GET',
-      url: '/movies'
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    assert.deepStrictEqual(res.json(), [])
-  }
-
-  let id
-  {
-    const res = await server.inject({
-      method: 'POST',
-      url: '/movies',
-      body: {
-        title: 'The Matrix'
-      }
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    const body = res.json()
-    assert.strictEqual(body.title, 'The Matrix')
-    assert.strictEqual(body.id !== undefined, true)
-    id = body.id
-  }
-
-  {
-    const res = await server.inject({
-      method: 'GET',
-      url: '/movies'
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    assert.deepStrictEqual(res.json(), [{
-      id,
-      title: 'The Matrix'
-    }])
-  }
-})
-`
-
-const moviesTestTS = `\
-import test from 'node:test'
-import assert from 'node:assert'
-import { getServer } from '../helper'
-
-test('movies', async (t) => {
-  const server = await getServer(t)
-
-  {
-    const res = await server.inject({
-      method: 'GET',
-      url: '/movies'
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    assert.deepStrictEqual(res.json(), [])
-  }
-
-  let id : Number
-  {
-    const res = await server.inject({
-      method: 'POST',
-      url: '/movies',
-      body: {
-        title: 'The Matrix'
-      }
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    const body = res.json()
-    assert.strictEqual(body.title, 'The Matrix')
-    assert.strictEqual(body.id !== undefined, true)
-    id = body.id as Number
-  }
-
-  {
-    const res = await server.inject({
-      method: 'GET',
-      url: '/movies'
-    })
-
-    assert.strictEqual(res.statusCode, 200)
-    assert.deepStrictEqual(res.json(), [{
-      id,
-      title: 'The Matrix'
-    }])
-  }
-})
-`
-
-function generateConfig (isRuntimeContext, migrations, plugin, types, typescript, version, envPrefix) {
-  const connectionStringValue = envPrefix ? `PLT_${envPrefix}DATABASE_URL` : 'DATABASE_URL'
-  const config = {
-    $schema: `https://platformatic.dev/schemas/v${version}/db`,
-    db: {
-      connectionString: `{${connectionStringValue}}`,
-      graphql: true,
-      openapi: true,
-      schemalock: true
-    },
-    watch: {
-      ignore: ['*.sqlite', '*.sqlite-journal']
-    }
-  }
-
-  if (!isRuntimeContext) {
-    config.server = {
-      hostname: '{PLT_SERVER_HOSTNAME}',
-      port: '{PORT}',
-      logger: {
-        level: '{PLT_SERVER_LOGGER_LEVEL}'
-      }
-    }
-  }
-
-  if (migrations) {
-    config.migrations = {
-      dir: migrations
-    }
-  }
-
-  if (plugin === true) {
-    config.plugins = {
-      paths: [{
-        path: './plugins',
-        encapsulate: false
-      }, {
-        path: './routes'
-      }]
-    }
-  }
-
-  if (types === true) {
-    config.types = {
-      autogenerate: true
-    }
-  }
-
-  if (typescript === true && config.plugins) {
-    config.plugins.typescript = `{PLT_${envPrefix}TYPESCRIPT}`
-  }
-
-  return config
-}
-
-function generateEnv (isRuntimeContext, hostname, port, connectionString, typescript, envPrefix) {
-  let env = ''
-  if (envPrefix) {
-    env += `PLT_${envPrefix}`
-  }
-  env += `DATABASE_URL=${connectionString}\n`
-
-  if (!isRuntimeContext) {
-    env += `\
-PLT_SERVER_HOSTNAME=${hostname}
-PORT=${port}
-PLT_SERVER_LOGGER_LEVEL=info
-
-  `
-  }
-
-  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
-}
-
-export function getConnectionString (database) {
-  return connectionStrings[database]
-}
-
-export async function createDB (params, logger, currentDir, version) {
-  let {
-    isRuntimeContext,
-    hostname,
-    port,
-    database = 'sqlite',
-    migrations = 'migrations',
-    plugin = true,
-    types = true,
-    typescript = false,
-    connectionString,
-    staticWorkspaceGitHubAction,
-    dynamicWorkspaceGitHubAction,
-    runtimeContext,
-    initGitRepository
-  } = params
-
-  const dbEnv = {
-    DATABASE_URL: connectionString,
-    PLT_SERVER_LOGGER_LEVEL: 'info',
-    PORT: port,
-    PLT_SERVER_HOSTNAME: hostname
-  }
-
-  if (typescript) {
-    dbEnv.PLT_TYPESCRIPT = true
-  }
-  connectionString = connectionString || getConnectionString(database)
-  const createMigrations = !!migrations // If we don't define a migrations folder, we don't create it
-  const envPrefix = runtimeContext !== undefined ? `${runtimeContext.envPrefix}_` : ''
-
-  const config = generateConfig(isRuntimeContext, migrations, plugin, types, typescript, version, envPrefix)
-  await writeFile(join(currentDir, 'platformatic.db.json'), JSON.stringify(config, null, 2))
-  logger.info('Configuration file platformatic.db.json successfully created.')
-
-  const env = generateEnv(isRuntimeContext, hostname, port, connectionString, typescript, envPrefix)
-  const envSample = generateEnv(isRuntimeContext, hostname, port, getConnectionString(database), typescript, envPrefix)
-  await appendFile(join(currentDir, '.env'), env)
-  await writeFile(join(currentDir, '.env.sample'), envSample)
-
-  const migrationsFolderName = migrations
-  if (createMigrations) {
-    await safeMkdir(join(currentDir, migrationsFolderName))
-    logger.info(`Migrations folder ${migrationsFolderName} successfully created.`)
-  }
-
-  const migrationFileNameDo = '001.do.sql'
-  const migrationFileNameUndo = '001.undo.sql'
-  const migrationFilePathDo = join(currentDir, migrationsFolderName, migrationFileNameDo)
-  const migrationFilePathUndo = join(currentDir, migrationsFolderName, migrationFileNameUndo)
-  if (createMigrations) {
-    await writeFile(migrationFilePathDo, moviesMigrationDo(database))
-    logger.info(`Migration file ${migrationFileNameDo} successfully created.`)
-    await writeFile(migrationFilePathUndo, moviesMigrationUndo)
-    logger.info(`Migration file ${migrationFileNameUndo} successfully created.`)
-  }
-
-  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.`)
-  }
-
-  if (plugin) {
-    let jsHelper = { pre: '', config: '', post: '' }
-    switch (database) {
-      case 'sqlite':
-        jsHelper = jsHelperSqlite
-        break
-      case 'mysql':
-        jsHelper = jsHelperMySQL(connectionString)
-        break
-      case 'postgres':
-        jsHelper = jsHelperPostgres(connectionString)
-        break
-      case 'mariadb':
-        jsHelper = jsHelperMySQL(connectionString)
-        break
-    }
-    await generatePlugins(logger, currentDir, typescript, 'db', jsHelper)
-
-    if (createMigrations) {
-      if (typescript) {
-        await writeFile(join(currentDir, 'test', 'routes', 'movies.test.ts'), moviesTestTS)
-      } else {
-        await writeFile(join(currentDir, 'test', 'routes', 'movies.test.js'), moviesTestJS)
-      }
-    }
-  }
-
-  if (staticWorkspaceGitHubAction) {
-    await createStaticWorkspaceGHAction(logger, dbEnv, './platformatic.db.json', currentDir, typescript)
-  }
-  if (dynamicWorkspaceGitHubAction) {
-    await createDynamicWorkspaceGHAction(logger, dbEnv, './platformatic.db.json', currentDir, typescript)
-  }
-
-  if (initGitRepository) {
-    await createGitRepository(logger, currentDir)
-  }
-
-  if (isRuntimeContext) {
-    return addPrefixToEnv(isRuntimeContext)
-  }
-
-  return dbEnv
-}
-
-export default createDB