create-platformatic 0.46.1 → 0.47.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "0.46.1",
+  "version": "0.47.0",
   "description": "Create platformatic-db interactive tool",
   "repository": {
     "type": "git",
@@ -34,7 +34,7 @@
     "semver": "^7.5.1",
     "undici": "^5.22.1",
     "which": "^3.0.1",
-    "@platformatic/config": "0.46.1"
+    "@platformatic/config": "0.47.0"
   },
   "devDependencies": {
     "ajv": "^8.12.0",
@@ -47,8 +47,8 @@
     "tap": "^16.3.6",
     "typescript": "~5.2.0",
     "yaml": "^2.3.1",
-    "@platformatic/db": "0.46.1",
-    "@platformatic/service": "0.46.1"
+    "@platformatic/db": "0.47.0",
+    "@platformatic/service": "0.47.0"
   },
   "scripts": {
     "test": "standard | snazzy && cross-env NODE_OPTIONS=\"--loader=esmock --no-warnings\" c8 tap --no-coverage test/*test.mjs test/*/*test.mjs",

package/src/ask-dir.mjs

@@ -1,4 +1,3 @@
-import { validatePath } from './utils.mjs'
 import inquirer from 'inquirer'
 import { resolve } from 'path'
 
@@ -7,8 +6,7 @@ const askProjectDir = async (logger, defaultName, message = 'Where would you lik
     type: 'input',
     name: 'dir',
     message,
-    default: defaultName,
-    validate: validatePath
+    default: defaultName
   })
 
   const projectDir = resolve(process.cwd(), options.dir)

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

@@ -35,6 +35,16 @@ export const createReadme = async (logger, dir = '.') => {
   logger.debug(`${readmeFileName} successfully created.`)
 }
 
+export const getServicesToCompose = (servicesNames) => {
+  return {
+    type: 'checkbox',
+    name: 'servicesToCompose',
+    message: 'Which services do you want to expose via Platformatic Composer?',
+    choices: servicesNames,
+    default: []
+  }
+}
+
 const createPlatformaticComposer = async (_args, opts) => {
   const logger = opts.logger || pino(pretty({
     translateTime: 'SYS:HH:MM:ss',
@@ -55,14 +65,26 @@ const createPlatformaticComposer = async (_args, opts) => {
   const pkgManager = getPkgManager()
 
   const projectDir = opts.dir || await askDir(logger, '.')
+  const isRuntimeContext = opts.isRuntimeContext || false
 
   const toAsk = [getPort(args.port)]
 
+  if (isRuntimeContext) {
+    const servicesNames = opts.runtimeContext.servicesNames.filter(
+      (serviceName) => serviceName !== opts.serviceName
+    )
+    toAsk.push(getServicesToCompose(servicesNames))
+  }
+
   if (!opts.skipPackageJson) {
     toAsk.push(getRunPackageManagerInstall(pkgManager))
   }
 
-  const { runPackageManagerInstall, port } = await inquirer.prompt(toAsk)
+  const {
+    runPackageManagerInstall,
+    servicesToCompose,
+    port
+  } = await inquirer.prompt(toAsk)
 
   // Create the project directory
   await mkdir(projectDir, { recursive: true })
@@ -72,7 +94,14 @@ const createPlatformaticComposer = async (_args, opts) => {
     port
   }
 
-  const env = await createComposer(params, logger, projectDir, version)
+  const env = await createComposer(
+    params,
+    logger,
+    projectDir,
+    version,
+    isRuntimeContext,
+    servicesToCompose
+  )
 
   const fastifyVersion = await getDependencyVersion('fastify')
 

package/src/composer/create-composer.mjs

@@ -3,7 +3,7 @@ import { findComposerConfigFile, isFileAccessible } from '../utils.mjs'
 import { join } from 'path'
 import * as desm from 'desm'
 
-function generateConfig (version) {
+function generateConfig (version, isRuntimeContext, servicesToCompose) {
   const config = {
     $schema: `https://platformatic.dev/schemas/v${version}/composer`,
     server: {
@@ -26,21 +26,45 @@ function generateConfig (version) {
     watch: true
   }
 
+  if (isRuntimeContext) {
+    config.composer.services = servicesToCompose.map((serviceName) => {
+      return {
+        id: serviceName,
+        openapi: {
+          url: '/documentation/json',
+          prefix: `/${serviceName}`
+        }
+      }
+    })
+  }
+
   return config
 }
 
-function generateEnv (hostname, port) {
-  const env = `\
+function generateEnv (isRuntimeContext, hostname, port) {
+  let env = `\
 PLT_SERVER_HOSTNAME=${hostname}
 PORT=${port}
 PLT_SERVER_LOGGER_LEVEL=info
+`
+
+  if (!isRuntimeContext) {
+    env += `\
 PLT_EXAMPLE_ORIGIN=
 `
+  }
 
   return env
 }
 
-async function createComposer ({ hostname, port }, logger, currentDir = process.cwd(), version) {
+async function createComposer (
+  { hostname, port },
+  logger,
+  currentDir = process.cwd(),
+  version,
+  isRuntimeContext = false,
+  servicesToCompose = []
+) {
   if (!version) {
     const pkg = await readFile(desm.join(import.meta.url, '..', '..', 'package.json'))
     version = JSON.parse(pkg).version
@@ -48,11 +72,11 @@ async function createComposer ({ hostname, port }, logger, currentDir = process.
   const accessibleConfigFilename = await findComposerConfigFile(currentDir)
 
   if (accessibleConfigFilename === undefined) {
-    const config = generateConfig(version)
+    const config = generateConfig(version, isRuntimeContext, servicesToCompose)
     await writeFile(join(currentDir, 'platformatic.composer.json'), JSON.stringify(config, null, 2))
     logger.info('Configuration file platformatic.composer.json successfully created.')
 
-    const env = generateEnv(hostname, port)
+    const env = generateEnv(isRuntimeContext, hostname, port)
     const envFileExists = await isFileAccessible('.env', currentDir)
     await appendFile(join(currentDir, '.env'), env)
     await writeFile(join(currentDir, '.env.sample'), env)

package/src/db/create-db.mjs

@@ -351,7 +351,7 @@ export async function createDB ({ hostname, database = 'sqlite', port, migration
   if (createMigrations) {
     const isMigrationFolderExists = await isFileAccessible(migrationsFolderName, currentDir)
     if (!isMigrationFolderExists) {
-      await mkdir(join(currentDir, migrationsFolderName))
+      await mkdir(join(currentDir, migrationsFolderName), { recursive: true })
       logger.info(`Migrations folder ${migrationsFolderName} successfully created.`)
     } else {
       logger.info(`Migrations folder ${migrationsFolderName} found, skipping creation of migrations folder.`)

package/src/ghaction.mjs

@@ -59,12 +59,29 @@ ${envString}
         run: npm run build`
 : ''}
       - name: Deploy project
+        id: deploy-project
         uses: platformatic/onestep@latest
         with:
           github_token: \${{ secrets.GITHUB_TOKEN }}
           platformatic_workspace_id: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_ID }}
           platformatic_workspace_key: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY }}
           platformatic_config_path: ${config}
+    outputs:
+      deployment_id: \${{ steps.deploy-project.outputs.deployment_id }}
+  calculate_risk:
+    permissions:
+      contents: read
+      pull-requests: write
+    needs: build_and_deploy
+    runs-on: ubuntu-latest
+    steps:
+      - name: Calculate risk
+        uses: platformatic/onestep/actions/calculate-risk@latest
+        with:
+          github_token: \${{ secrets.GITHUB_TOKEN }}
+          platformatic_workspace_id: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_ID }}
+          platformatic_workspace_key: \${{ secrets.PLATFORMATIC_DYNAMIC_WORKSPACE_API_KEY }}
+          platformatic_deployment_id: \${{ needs.build_and_deploy.outputs.deployment_id }}
 `
 }
 

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

@@ -50,7 +50,7 @@ export async function createPlatformaticRuntime (_args) {
   // Create the project directory
   await mkdir(projectDir, { recursive: true })
 
-  const baseServicesDir = join(relative(process.cwd(), projectDir), 'library-app/services')
+  const baseServicesDir = join(relative(process.cwd(), projectDir), 'services')
   const servicesDir = await askDir(logger, baseServicesDir, 'Where would you like to load your services from?')
 
   const { runPackageManagerInstall } = await inquirer.prompt([
@@ -151,12 +151,17 @@ export async function createRuntimeService ({ servicesDir, names, logger }) {
 
   await chooseKind([], {
     skip: 'runtime',
+    serviceName: name,
     dir: serviceDir,
     logger,
     skipGitHubActions: true,
     skipPackageJson: true,
     skipGitignore: true,
-    port: '0'
+    port: '0',
+    isRuntimeContext: true,
+    runtimeContext: {
+      servicesNames: names
+    }
   })
 
   return true

package/src/utils.mjs

@@ -61,19 +61,6 @@ export async function isDirectoryWriteable (directory) {
   }
 }
 
-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)
-  return canAccessParent
-}
-
 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'))

package/test/cli-options.test.mjs

@@ -1,84 +0,0 @@
-import { test } from 'tap'
-import { getRunPackageManagerInstall, getUseTypescript, getPort, getOverwriteReadme } from '../src/cli-options.mjs'
-
-test('getRunPackageManagerInstall', async ({ same }) => {
-  same(
-    getRunPackageManagerInstall('npm'),
-    {
-      type: 'list',
-      name: 'runPackageManagerInstall',
-      message: 'Do you want to run npm install?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    }
-  )
-})
-
-test('getUseTypescript', async ({ same }) => {
-  same(
-    getUseTypescript(true),
-    {
-      type: 'list',
-      when: false,
-      name: 'useTypescript',
-      message: 'Do you want to use TypeScript?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    }
-  )
-})
-
-test('getOverwriteReadme', async ({ same }) => {
-  same(
-    getOverwriteReadme(),
-    {
-      type: 'list',
-      name: 'shouldReplace',
-      message: 'Do you want to overwrite the existing README.md?',
-      default: true,
-      choices: [{ name: 'yes', value: true }, { name: 'no', value: false }]
-    }
-  )
-})
-
-test('getPort', async ({ same }) => {
-  same(
-    getPort(undefined),
-    {
-      type: 'input',
-      name: 'port',
-      message: 'What port do you want to use?',
-      default: 3042
-    }
-  )
-
-  same(
-    getPort(undefined),
-    {
-      type: 'input',
-      name: 'port',
-      message: 'What port do you want to use?',
-      default: 3043
-    }
-  )
-
-  same(
-    getPort(1234),
-    {
-      type: 'input',
-      name: 'port',
-      message: 'What port do you want to use?',
-      default: 1234
-    }
-  )
-
-  same(
-    getPort(undefined),
-    {
-      type: 'input',
-      name: 'port',
-      message: 'What port do you want to use?',
-      default: 3044
-    }
-  )
-})

package/test/composer/create-composer.test.mjs

@@ -1,75 +0,0 @@
-import createComposer from '../../src/composer/create-composer.mjs'
-import { test, beforeEach, afterEach } from 'tap'
-import { tmpdir } from 'os'
-import { mkdtempSync, rmSync, readFileSync, writeFileSync } from 'fs'
-import { join } from 'path'
-import dotenv from 'dotenv'
-
-const base = tmpdir()
-let tmpDir
-let log = []
-beforeEach(() => {
-  tmpDir = mkdtempSync(join(base, 'test-create-platformatic-'))
-})
-
-afterEach(() => {
-  log = []
-  rmSync(tmpDir, { recursive: true, force: true })
-  process.env = {}
-})
-
-const fakeLogger = {
-  debug: msg => log.push(msg),
-  info: msg => log.push(msg)
-}
-
-test('creates composer', async ({ equal, same, ok }) => {
-  const params = {
-    hostname: 'myhost',
-    port: 6666,
-    typescript: false
-  }
-
-  await createComposer(params, fakeLogger, tmpDir)
-
-  const pathToComposerConfigFile = join(tmpDir, 'platformatic.composer.json')
-  const composerConfigFile = readFileSync(pathToComposerConfigFile, 'utf8')
-  const composerConfig = JSON.parse(composerConfigFile)
-  const { server, composer } = composerConfig
-
-  equal(server.hostname, '{PLT_SERVER_HOSTNAME}')
-  equal(server.port, '{PORT}')
-
-  const pathToDbEnvFile = join(tmpDir, '.env')
-  dotenv.config({ path: pathToDbEnvFile })
-  equal(process.env.PLT_SERVER_HOSTNAME, 'myhost')
-  equal(process.env.PORT, '6666')
-  process.env = {}
-
-  const pathToDbEnvSampleFile = join(tmpDir, '.env.sample')
-  dotenv.config({ path: pathToDbEnvSampleFile })
-  equal(process.env.PLT_SERVER_HOSTNAME, 'myhost')
-  equal(process.env.PORT, '6666')
-
-  same(composer, {
-    services: [{
-      id: 'example',
-      origin: '{PLT_EXAMPLE_ORIGIN}',
-      openapi: {
-        url: '/documentation/json'
-      }
-    }],
-    refreshTimeout: 1000
-  })
-})
-
-test('creates project with configuration already present', async ({ ok }) => {
-  const pathToComposerConfigFileOld = join(tmpDir, 'platformatic.composer.json')
-  writeFileSync(pathToComposerConfigFileOld, JSON.stringify({ test: 'test' }))
-  const params = {
-    hostname: 'myhost',
-    port: 6666
-  }
-  await createComposer(params, fakeLogger, tmpDir)
-  ok(log.includes('Configuration file platformatic.composer.json found, skipping creation of configuration file.'))
-})

package/test/create-gitignore.test.mjs

@@ -1,35 +0,0 @@
-import { test, beforeEach, afterEach } from 'tap'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../src/utils.mjs'
-import { createGitignore } from '../src/create-gitignore.mjs'
-import { mkdtempSync, rmSync, writeFileSync } from 'fs'
-import { join } from 'path'
-
-let log = ''
-const fakeLogger = {
-  debug: msg => { log = msg }
-}
-
-let tmpDir
-beforeEach(() => {
-  log = ''
-  tmpDir = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true })
-})
-
-test('creates gitignore file', async ({ end, equal }) => {
-  await createGitignore(fakeLogger, tmpDir)
-  equal(log, `Gitignore file ${join(tmpDir, '.gitignore')} successfully created.`)
-  const accessible = await isFileAccessible(join(tmpDir, '.gitignore'))
-  equal(accessible, true)
-})
-
-test('do not create gitignore file because already present', async ({ end, equal }) => {
-  const gitignore = join(tmpDir, '.gitignore')
-  writeFileSync(gitignore, 'TEST')
-  await createGitignore(fakeLogger, tmpDir)
-  equal(log, `Gitignore file ${join(tmpDir, '.gitignore')} found, skipping creation of gitignore file.`)
-})

package/test/create-package-json.test.mjs

@@ -1,81 +0,0 @@
-import { test, beforeEach, afterEach } from 'tap'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../src/utils.mjs'
-import { createPackageJson } from '../src/create-package-json.mjs'
-import { mkdtempSync, rmSync, writeFileSync, readFileSync } from 'fs'
-import { join } from 'path'
-
-let log = ''
-const fakeLogger = {
-  debug: msg => { log = msg }
-}
-
-let tmpDir
-beforeEach(() => {
-  log = ''
-  tmpDir = mkdtempSync(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-afterEach(() => {
-  rmSync(tmpDir, { recursive: true, force: true })
-})
-
-test('creates package.json file for db project', async ({ equal }) => {
-  const version = '1.2.3'
-  const fastifyVersion = '4.5.6'
-  const addTSBuild = false
-  const scripts = {}
-  const dependencies = {
-    '@platformatic/db': `^${version}`
-  }
-  await createPackageJson(version, fastifyVersion, fakeLogger, tmpDir, addTSBuild, scripts, dependencies)
-  equal(log, `${join(tmpDir, 'package.json')} successfully created.`)
-  const accessible = await isFileAccessible(join(tmpDir, 'package.json'))
-  equal(accessible, true)
-  const packageJson = JSON.parse(readFileSync(join(tmpDir, 'package.json')))
-  equal(packageJson.scripts.start, 'platformatic start')
-  equal(packageJson.scripts.build, undefined)
-  equal(packageJson.dependencies.platformatic, `^${version}`)
-  equal(packageJson.dependencies['@platformatic/db'], `^${version}`)
-  equal(packageJson.devDependencies.fastify, `^${fastifyVersion}`)
-})
-
-test('creates package.json file for service project', async ({ equal }) => {
-  const version = '1.2.3'
-  const fastifyVersion = '4.5.6'
-  const addTSBuild = false
-  await createPackageJson(version, fastifyVersion, fakeLogger, tmpDir, addTSBuild)
-  equal(log, `${join(tmpDir, 'package.json')} successfully created.`)
-  const accessible = await isFileAccessible(join(tmpDir, 'package.json'))
-  equal(accessible, true)
-  const packageJson = JSON.parse(readFileSync(join(tmpDir, 'package.json')))
-  equal(packageJson.scripts.start, 'platformatic start')
-  equal(packageJson.dependencies.platformatic, `^${version}`)
-  equal(packageJson.devDependencies.fastify, `^${fastifyVersion}`)
-})
-
-test('do not create package.json file because already present', async ({ equal }) => {
-  const version = '1.2.3'
-  const fastifyVersion = '4.5.6'
-  const addTSBuild = false
-  const packagejson = join(tmpDir, 'package.json')
-  writeFileSync(packagejson, 'TEST')
-  await createPackageJson(version, fastifyVersion, fakeLogger, tmpDir, addTSBuild)
-  equal(log, `${join(tmpDir, 'package.json')} found, skipping creation of package.json file.`)
-})
-
-test('creates package.json file with TS build', async ({ equal }) => {
-  const version = '1.2.3'
-  const fastifyVersion = '4.5.6'
-  const addTSBuild = true
-  await createPackageJson(version, fastifyVersion, fakeLogger, tmpDir, addTSBuild)
-  equal(log, `${join(tmpDir, 'package.json')} successfully created.`)
-  const accessible = await isFileAccessible(join(tmpDir, 'package.json'))
-  equal(accessible, true)
-  const packageJson = JSON.parse(readFileSync(join(tmpDir, 'package.json')))
-  equal(packageJson.scripts.start, 'platformatic start')
-  equal(packageJson.scripts.clean, 'rm -fr ./dist')
-  equal(packageJson.scripts.build, 'platformatic compile')
-  equal(packageJson.dependencies.platformatic, `^${version}`)
-  equal(packageJson.devDependencies.fastify, `^${fastifyVersion}`)
-})