create-platformatic 2.0.0-alpha.7 → 2.0.0-alpha.8

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "create-platformatic",
-  "version": "2.0.0-alpha.7",
+  "version": "2.0.0-alpha.8",
   "description": "Create platformatic application interactive tool",
   "repository": {
     "type": "git",
@@ -34,9 +34,9 @@
     "strip-ansi": "^7.1.0",
     "undici": "^6.9.0",
     "which": "^3.0.1",
-    "@platformatic/config": "2.0.0-alpha.7",
-    "@platformatic/generators": "2.0.0-alpha.7",
-    "@platformatic/utils": "2.0.0-alpha.7"
+    "@platformatic/config": "2.0.0-alpha.8",
+    "@platformatic/generators": "2.0.0-alpha.8",
+    "@platformatic/utils": "2.0.0-alpha.8"
   },
   "devDependencies": {
     "@types/node": "^22.5.0",
@@ -49,12 +49,12 @@
     "esmock": "^2.6.4",
     "fastify": "^4.26.2",
     "neostandard": "^0.11.1",
-    "typescript": "~5.5.4",
+    "typescript": "~5.6.0",
     "yaml": "^2.4.1",
-    "@platformatic/composer": "2.0.0-alpha.7",
-    "@platformatic/db": "2.0.0-alpha.7",
-    "@platformatic/runtime": "2.0.0-alpha.7",
-    "@platformatic/service": "2.0.0-alpha.7"
+    "@platformatic/composer": "2.0.0-alpha.8",
+    "@platformatic/db": "2.0.0-alpha.8",
+    "@platformatic/runtime": "2.0.0-alpha.8",
+    "@platformatic/service": "2.0.0-alpha.8"
   },
   "scripts": {
     "test:cli": "borp --pattern \"test/cli/*test.mjs\" --timeout=180000 --concurrency=1",

package/test/cli/README.md

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

package/test/cli/composer.test.mjs

@@ -1,84 +0,0 @@
-import { safeRemove } from '@platformatic/utils'
-import { mkdtemp } from 'fs/promises'
-import { equal } from 'node:assert'
-import { join } from 'node:path'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../../src/utils.mjs'
-import { executeCreatePlatformatic, getServices, keys, startMarketplace, walk } from './helper.mjs'
-import { timeout } from './timeout.mjs'
-
-let tmpDir
-test.beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-test.afterEach(async () => {
-  try {
-    await safeRemove(tmpDir)
-  } catch (e) {
-    // on purpose, in win the resource might be still "busy"
-  }
-})
-
-test('Creates a Platformatic Composer', { timeout }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.UP, keys.UP, keys.ENTER], // Composer
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
-      match: 'Do you want to use TypeScript',
-      do: [keys.ENTER], // no
-      waitAfter: 8000,
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
-
-  // Here check the generated service
-  const services = await getServices(join(baseProjectDir, 'services'))
-  equal(services.length, 1)
-  const baseServiceDir = join(baseProjectDir, 'services', services[0])
-  console.log(baseServiceDir)
-  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
-})

package/test/cli/db.test.mjs

@@ -1,92 +0,0 @@
-import { safeRemove } from '@platformatic/utils'
-import { mkdtemp } from 'fs/promises'
-import { equal } from 'node:assert'
-import { join } from 'node:path'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../../src/utils.mjs'
-import { executeCreatePlatformatic, getServices, keys, startMarketplace, walk } from './helper.mjs'
-import { timeout } from './timeout.mjs'
-
-let tmpDir
-test.beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-test.afterEach(async () => {
-  try {
-    await safeRemove(tmpDir)
-  } catch (e) {
-    // on purpose, in win the resource might be still "busy"
-  }
-})
-
-test('Creates a Platformatic DB service with no migrations', { timeout }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.UP, keys.ENTER], // DB
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'What is the connection string?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create default migrations',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
-      match: 'Do you want to use TypeScript',
-      do: [keys.ENTER], // no
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
-
-  // Here check the generated service
-  const services = await getServices(join(baseProjectDir, 'services'))
-  equal(services.length, 1)
-  const baseServiceDir = join(baseProjectDir, 'services', services[0])
-  console.log(baseServiceDir)
-  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'migrations')), false)
-  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
-})

package/test/cli/helper.mjs

@@ -1,159 +0,0 @@
-import os from 'node:os'
-import { execa } from 'execa'
-import { join } from 'desm'
-import stripAnsi from 'strip-ansi'
-import { promisify } from 'node:util'
-import { promises as fs } from 'node:fs'
-import path from 'node:path'
-import fastify from 'fastify'
-
-const sleep = promisify(setTimeout)
-
-export const keys = {
-  DOWN: '\x1B\x5B\x42',
-  UP: '\x1B\x5B\x41',
-  ENTER: '\x0D',
-  SPACE: '\x20',
-}
-
-export const createPath = join(import.meta.url, '..', '..', 'create-platformatic.mjs')
-
-const match = (str, match) => {
-  if (Array.isArray(match)) {
-    return match.some((m) => str.includes(m))
-  }
-  return str.includes(match)
-}
-
-export const walk = async (dir) => {
-  let files = await fs.readdir(dir)
-  files = await Promise.all(files.map(async file => {
-    const filePath = path.join(dir, file)
-    const stats = await fs.stat(filePath)
-    if (stats.isDirectory()) return walk(filePath)
-    else if (stats.isFile()) return filePath
-  }))
-  return files.reduce((all, folderContents) => all.concat(folderContents), [])
-}
-
-export const getServices = async (dir) => {
-  const files = await fs.readdir(dir)
-  const services = []
-  for (const file of files) {
-    services.push(file)
-  }
-  return services
-}
-
-// Actions are in the form:
-// {
-//    match: 'Server listening at',
-//    do: [keys.DOWN, keys.ENTER]
-// }
-export async function executeCreatePlatformatic (dir, actions = [], options = {}) {
-  const done = options.done || 'You are all set!'
-  const pkgMgrInstall = options.pkgMgrInstall || false
-  const pkgManager = options.pkgManager || 'npm'
-  const marketplaceHost = options.marketplaceHost
-
-  const runCreatePlatformatic = async () => {
-    const questions = [...actions]
-    try {
-      const execaOptions = {
-        cwd: dir,
-      }
-
-      if (pkgManager === 'pnpm') {
-        execaOptions.env = {
-          npm_config_user_agent: 'pnpm/6.14.1 npm/? node/v16.4.2 darwin x64',
-        }
-      }
-
-      const child = execa('node', [
-        createPath,
-        `--install=${pkgMgrInstall.toString()}`,
-        `--marketplace-host=${marketplaceHost}`,
-      ], execaOptions)
-
-      // We just need the "lastPrompt" printed before the process stopped to wait for an answer
-      // If we don't have any outptu from process for more than 500ms, we assume it's waiting for an answer
-      let lastPrompt = ''
-
-      child.stdout.on('data', (chunk) => {
-        const str = stripAnsi(chunk.toString()).trim()
-        if (str) {
-          lastPrompt = str
-        }
-      })
-
-      let expectedQuestion = questions.shift()
-
-      // We need this because the prompt prints an introduction before asking anything.
-      // If we don't like this, we could use a flag to recognize when the introduction is done
-      await sleep(5000)
-
-      while (true) {
-        if (!expectedQuestion) {
-          await sleep(500)
-          // We processed all expected questions, so now we wait for the process to be done.
-          // If the "done" string is not printed, the test will timeout
-          if (lastPrompt && lastPrompt.includes(done)) {
-            safeKill(child)
-            return
-          }
-        } else if (match(lastPrompt, expectedQuestion.match)) {
-          console.log('==> MATCH', expectedQuestion.match)
-          lastPrompt = ''
-
-          for (const key of expectedQuestion.do) {
-            child.stdin?.write(key)
-            const waitAfter = expectedQuestion.waitAfter || 500
-            await sleep(waitAfter)
-          }
-          expectedQuestion = questions.shift()
-        } else {
-          throw new Error(`Expected ${expectedQuestion.match}, got ${lastPrompt}`)
-        }
-      }
-    } catch (err) {
-      console.error(err)
-      throw err
-    }
-  }
-  await runCreatePlatformatic()
-}
-
-export async function safeKill (child) {
-  child.kill('SIGINT')
-  if (os.platform() === 'win32') {
-    try {
-      await execa('taskkill', ['/pid', child.pid, '/f', '/t'])
-    } catch (err) {
-      if (err.stderr.indexOf('not found') === 0) {
-        console.error(`Failed to kill process ${child.pid}`)
-        console.error(err)
-      }
-    }
-  }
-}
-
-export async function startMarketplace (t, opts = {}) {
-  const marketplace = fastify()
-
-  marketplace.get('/templates', async (request, reply) => {
-    if (opts.templatesCallback) {
-      return opts.templatesCallback(request, reply)
-    }
-    return [
-      { name: '@platformatic/composer' },
-      { name: '@platformatic/db' },
-      { name: '@platformatic/service' },
-    ]
-  })
-
-  await marketplace.listen({ port: 0 })
-  t.after(() => marketplace.close())
-
-  const address = marketplace.server.address()
-  return `http://127.0.0.1:${address.port}`
-}

package/test/cli/runtime.test.mjs

@@ -1,112 +0,0 @@
-import { safeRemove } from '@platformatic/utils'
-import { equal } from 'node:assert'
-import { mkdtemp } from 'node:fs/promises'
-import { tmpdir } from 'node:os'
-import { join } from 'node:path'
-import { test } from 'node:test'
-import { isFileAccessible } from '../../src/utils.mjs'
-import { executeCreatePlatformatic, getServices, keys, startMarketplace, walk } from './helper.mjs'
-import { timeout } from './timeout.mjs'
-
-let tmpDir
-test.beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-test.afterEach(async () => {
-  try {
-    await safeRemove(tmpDir)
-  } catch (e) {
-    // on purpose, in win the resource might be still "busy"
-  }
-})
-
-test('Creates a Platformatic Runtime with two Services', { timeout }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.ENTER], // Service
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.ENTER], // yes
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.ENTER], // Service
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      match: 'Which service should be exposed?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to use TypeScript',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, {
-    marketplaceHost,
-    pkgManager: 'pnpm',
-  })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.git', 'config')), true)
-
-  // using pnpm will create workspace file
-  equal(await isFileAccessible(join(baseProjectDir, 'pnpm-workspace.yaml')), true)
-
-  // Here check the generated services
-  const services = await getServices(join(baseProjectDir, 'services'))
-  equal(services.length, 2)
-  const baseService0Dir = join(baseProjectDir, 'services', services[0])
-  equal(await isFileAccessible(join(baseService0Dir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseService0Dir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseService0Dir, 'routes', 'root.ts')), true)
-  equal(await isFileAccessible(join(baseService0Dir, 'plugins', 'example.ts')), true)
-  equal(await isFileAccessible(join(baseService0Dir, 'global.d.ts')), true)
-
-  const baseService1Dir = join(baseProjectDir, 'services', services[1])
-  equal(await isFileAccessible(join(baseService1Dir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseService1Dir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseService1Dir, 'routes', 'root.ts')), true)
-  equal(await isFileAccessible(join(baseService1Dir, 'plugins', 'example.ts')), true)
-  equal(await isFileAccessible(join(baseService1Dir, 'global.d.ts')), true)
-})

package/test/cli/service.test.mjs

@@ -1,222 +0,0 @@
-import { createDirectory, safeRemove } from '@platformatic/utils'
-import { equal, notEqual } from 'node:assert'
-import { mkdtemp, readFile, writeFile } from 'node:fs/promises'
-import { join } from 'node:path'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../../src/utils.mjs'
-import { executeCreatePlatformatic, getServices, keys, startMarketplace, walk } from './helper.mjs'
-import { timeout } from './timeout.mjs'
-
-let tmpDir
-test.beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-test.afterEach(async () => {
-  try {
-    await safeRemove(tmpDir)
-  } catch (e) {
-    // on purpose, in win the resource might be still "busy"
-  }
-})
-
-test('Creates a Platformatic Service with no typescript', { timeout }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.ENTER], // Service
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
-      match: 'Do you want to use TypeScript',
-      do: [keys.ENTER], // no
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
-
-  // Here check the generated service
-  const services = await getServices(join(baseProjectDir, 'services'))
-  equal(services.length, 1)
-  const baseServiceDir = join(baseProjectDir, 'services', services[0])
-  console.log(baseServiceDir)
-  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.js')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.js')), true)
-})
-
-test('Creates a Platformatic Service with typescript', { timeout }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Which kind of project do you want to create?',
-      do: [keys.ENTER], // Service
-    },
-    {
-      match: 'What is the name of the service?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create another service?',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
-      match: 'Do you want to use TypeScript',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env')), true)
-  equal(await isFileAccessible(join(baseProjectDir, '.env.sample')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'README.md')), true)
-
-  // Here check the generated service
-  const services = await getServices(join(baseProjectDir, 'services'))
-  equal(services.length, 1)
-  const baseServiceDir = join(baseProjectDir, 'services', services[0])
-  console.log(baseServiceDir)
-  equal(await isFileAccessible(join(baseServiceDir, 'platformatic.json')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'README.md')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'routes', 'root.ts')), true)
-  equal(await isFileAccessible(join(baseServiceDir, 'plugins', 'example.ts')), true)
-})
-
-test('Creates a Platformatic Service in a non empty directory', { timeout, skip: true }, async t => {
-  const marketplaceHost = await startMarketplace(t)
-  const targetDirectory = join(tmpdir(), 'platformatic-service-test')
-  // const targetDirectory = '/tmp/tst'
-  async function generateServiceFileStructure (dir) {
-    const servicesDir = join(dir, 'services')
-    await createDirectory(servicesDir)
-
-    const serviceDir = join(servicesDir, 'foo')
-    await createDirectory(join(serviceDir, 'plugins'))
-    await createDirectory(join(serviceDir, 'routes'))
-
-    await writeFile(join(dir, '.env'), 'SAMPLE_ENV=foobar\n')
-
-    // creates 2 files. root.js will be overwritten
-    await writeFile(join(serviceDir, 'routes', 'root.js'), "console.log('hello world')")
-    await writeFile(join(serviceDir, 'routes', 'sample.js'), "console.log('hello world')")
-  }
-  // generate a sample file structure
-  await generateServiceFileStructure(targetDirectory)
-
-  test.after(async () => {
-    await safeRemove(targetDirectory)
-  })
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.ENTER], // Application
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [targetDirectory, keys.ENTER],
-      waitAfter: 8000,
-    },
-    {
-      match: 'Confirm you want to use',
-      do: [keys.ENTER], // confirm use existing directory
-    },
-    {
-      // NOTE THAT HERE THE DEFAULT OPTION FOR SERVICE IS "YES"
-      match: 'Do you want to use TypeScript',
-      do: [keys.DOWN, keys.ENTER], // no
-    },
-    {
-      match: 'What port do you want to use?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'Do you want to create the github action to deploy',
-      do: [keys.DOWN, keys.ENTER],
-    },
-    {
-      match: 'Do you want to enable PR Previews in your application',
-      do: [keys.DOWN, keys.ENTER],
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, { marketplaceHost })
-
-  equal(await isFileAccessible(join(targetDirectory, '.gitignore')), true)
-  equal(await isFileAccessible(join(targetDirectory, '.env')), true)
-  equal(await isFileAccessible(join(targetDirectory, '.env.sample')), true)
-  equal(await isFileAccessible(join(targetDirectory, 'platformatic.service.json')), true)
-  equal(await isFileAccessible(join(targetDirectory, 'README.md')), true)
-  equal(await isFileAccessible(join(targetDirectory, 'routes', 'root.js')), true)
-  equal(await isFileAccessible(join(targetDirectory, 'routes', 'sample.js')), true)
-  equal(await isFileAccessible(join(targetDirectory, 'plugins', 'example.js')), true)
-  equal(await isFileAccessible(join(targetDirectory, '.git', 'config')), true)
-
-  // check file contents
-  notEqual(await readFile(join(targetDirectory, 'routes', 'root.js'), 'utf8'), "console.log('hello world')")
-  equal(await readFile(join(targetDirectory, 'routes', 'sample.js'), 'utf8'), "console.log('hello world')")
-})

package/test/cli/stackable.test.mjs

@@ -1,114 +0,0 @@
-import { safeRemove } from '@platformatic/utils'
-import { equal } from 'node:assert'
-import { mkdtemp } from 'node:fs/promises'
-import { join } from 'node:path'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { isFileAccessible } from '../../src/utils.mjs'
-import { executeCreatePlatformatic, keys, walk } from './helper.mjs'
-import { timeout } from './timeout.mjs'
-
-let tmpDir
-test.beforeEach(async () => {
-  tmpDir = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-})
-
-test.afterEach(async () => {
-  try {
-    await safeRemove(tmpDir)
-  } catch (e) {
-    // on purpose, in win the resource might be still "busy"
-  }
-})
-
-test('Creates a Platformatic Stackable without typescript', { timeout }, async () => {
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.DOWN, keys.ENTER], // Stackable
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'What is the name of the stackable?',
-      do: [keys.ENTER], // my-stackable
-    },
-    {
-      match: 'Do you want to use TypeScript',
-      do: [keys.ENTER], // no
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, {
-    done: 'Stackable created successfully!',
-  })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'index.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'index.d.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'config.d.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'package.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'plugins', 'example.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'lib', 'schema.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'lib', 'generator.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'cli', 'create.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'cli', 'start.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'index.test.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'schema.test.js')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'generator.test.js')), true)
-})
-
-test('Creates a Platformatic Stackable with typescript', { timeout }, async () => {
-  // The actions must match IN ORDER
-  const actions = [
-    {
-      match: 'What kind of project do you want to create?',
-      do: [keys.DOWN, keys.ENTER], // Stackable
-    },
-    {
-      match: 'Where would you like to create your project?',
-      do: [keys.ENTER],
-    },
-    {
-      match: 'What is the name of the stackable?',
-      do: [keys.ENTER], // my-stackable
-    },
-    {
-      match: 'Do you want to use TypeScript',
-      do: [keys.DOWN, keys.ENTER], // yes
-    },
-    {
-      match: 'Do you want to init the git repository',
-      do: [keys.ENTER], // no
-    },
-  ]
-  await executeCreatePlatformatic(tmpDir, actions, {
-    done: 'Stackable created successfully!',
-  })
-
-  const baseProjectDir = join(tmpDir, 'platformatic')
-  const files = await walk(baseProjectDir)
-  console.log('==> created files', files)
-  equal(await isFileAccessible(join(baseProjectDir, '.gitignore')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'index.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'index.d.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'config.d.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'package.json')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'plugins', 'example.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'lib', 'schema.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'lib', 'generator.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'cli', 'create.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'cli', 'start.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'index.test.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'schema.test.ts')), true)
-  equal(await isFileAccessible(join(baseProjectDir, 'test', 'generator.test.ts')), true)
-})

package/test/cli/timeout.mjs

@@ -1,3 +0,0 @@
-'use strict'
-
-export const timeout = 120_000

package/test/unit/create-git-repository.test.mjs

@@ -1,67 +0,0 @@
-import { execa } from 'execa'
-import { equal, match } from 'node:assert'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { join } from 'path'
-
-import { createDirectory } from '@platformatic/utils'
-import { writeFile } from 'fs/promises'
-import { createGitRepository, GIT_FIRST_COMMIT_MESSAGE, GIT_MAIN_BRANCH } from '../../src/create-git-repository.mjs'
-import { isFileAccessible } from '../../src/utils.mjs'
-
-const loggerSpy = {
-  _debug: [],
-  _info: [],
-  _error: [],
-
-  debug: function (...args) {
-    this._debug.push(args)
-  },
-  info: function (...args) {
-    this._info.push(args)
-  },
-  error: function (...args) {
-    this._error.push(args)
-  },
-
-  reset: function () {
-    this._debug = []
-    this._info = []
-    this._error = []
-  },
-}
-
-const tmpDir = join(tmpdir(), 'test-create-platformatic-git-repo')
-test.beforeEach(async () => {
-  loggerSpy.reset()
-  await createDirectory(tmpDir, true)
-})
-
-test('should create the git repo', async () => {
-  await writeFile(join(tmpDir, 'README.md'), '')
-
-  await createGitRepository(loggerSpy, tmpDir)
-
-  equal(loggerSpy._debug[0][0], 'Git repository initialized.')
-  equal(loggerSpy._debug[1][0], 'Git commit done.')
-  equal(loggerSpy._info[0][0], 'Git repository initialized.')
-  equal(loggerSpy._error.length, 0)
-
-  equal(await isFileAccessible(join(tmpDir, '.git/config')), true)
-
-  const lastCommit = await execa('git', ['show', '-1'], { cwd: tmpDir })
-  match(lastCommit.stdout, new RegExp(GIT_FIRST_COMMIT_MESSAGE))
-
-  const branch = await execa('git', ['branch'], { cwd: tmpDir })
-  match(branch.stdout, new RegExp(GIT_MAIN_BRANCH))
-})
-
-test('should not create the git repository if already exists', async () => {
-  await execa('git', ['init'], { cwd: tmpDir })
-
-  await createGitRepository(loggerSpy, tmpDir)
-
-  equal(loggerSpy._debug.length, 0)
-  equal(loggerSpy._info[0][0], 'Git repository already exists.')
-  equal(loggerSpy._error.length, 0)
-})

package/test/unit/fetch-stackables.mjs

@@ -1,71 +0,0 @@
-import { test } from 'node:test'
-import { deepEqual } from 'node:assert'
-import { MockAgent, setGlobalDispatcher } from 'undici'
-import { fetchStackables } from '../../src/index.mjs'
-import { setTimeout } from 'node:timers/promises'
-
-const mockAgent = new MockAgent({
-  keepAliveTimeout: 10,
-  keepAliveMaxTimeout: 10,
-})
-mockAgent.disableNetConnect()
-
-setGlobalDispatcher(mockAgent)
-
-const MARKETPLACE_HOST = 'https://marketplace.platformatic.dev'
-
-const mockPool = mockAgent.get(MARKETPLACE_HOST)
-const defaultStackables = ['@platformatic/composer', '@platformatic/db', '@platformatic/service']
-
-test('should fetch stackables from the marketplace', async () => {
-  const mockStackables = [
-    { name: 'mock-service-1' },
-    { name: 'mock-service-2' },
-    { name: 'mock-service-3' },
-  ]
-
-  mockPool.intercept({ path: '/templates' }).reply(200, mockStackables)
-
-  const stackables = await fetchStackables()
-  deepEqual(stackables, mockStackables.map(s => s.name))
-})
-
-test('should fetch private stackables from the marketplace', async () => {
-  const mockStackables = [
-    { name: 'mock-service-1' },
-    { name: 'mock-service-2' },
-    { name: 'mock-service-3' },
-    { name: 'private-mock-service-1' },
-  ]
-
-  mockPool.intercept({ path: '/templates' }).reply(200, mockStackables)
-
-  const stackables = await fetchStackables(MARKETPLACE_HOST)
-  deepEqual(stackables, mockStackables.map(s => s.name))
-})
-
-test('should fetch only public stackables if user api key is wrong', async () => {
-  const mockStackables = [
-    { name: 'mock-service-1' },
-    { name: 'mock-service-2' },
-    { name: 'mock-service-3' },
-  ]
-
-  mockPool.intercept({ path: '/templates' }).reply(401)
-  mockPool.intercept({ path: '/templates' }).reply(200, mockStackables)
-
-  const stackables = await fetchStackables(MARKETPLACE_HOST)
-  deepEqual(stackables, mockStackables.map(s => s.name))
-})
-
-test('should return default stackables if fetching from the marketplace takes too long', async () => {
-  mockPool.intercept({ path: '/templates' }).reply(200, async () => await setTimeout(6000, []))
-  const stackables = await fetchStackables()
-  deepEqual(stackables, defaultStackables)
-})
-
-test('should return default stackables if fetching from the marketplace errors', async () => {
-  mockPool.intercept({ path: '/templates' }).replyWithError(new Error())
-  const stackables = await fetchStackables()
-  deepEqual(stackables, defaultStackables)
-})

package/test/unit/utils.test.mjs

@@ -1,293 +0,0 @@
-'use strict'
-
-import { safeRemove } from '@platformatic/utils'
-import esmock from 'esmock'
-import { mkdtemp, writeFile } from 'fs/promises'
-import { deepEqual, equal, notEqual } from 'node:assert'
-import { test } from 'node:test'
-import { tmpdir } from 'os'
-import { join } from 'path'
-import semver from 'semver'
-import {
-  addPrefixToEnv,
-  convertServiceNameToPrefix,
-  findComposerConfigFile,
-  findDBConfigFile,
-  findRuntimeConfigFile,
-  findServiceConfigFile,
-  getDependencyVersion,
-  isCurrentVersionSupported,
-  isFileAccessible,
-  minimumSupportedNodeVersions,
-  randomBetween,
-  sleep,
-} from '../../src/utils.mjs'
-
-test('getUsername from git', async () => {
-  const name = 'lukeskywalker'
-  const { getUsername } = await esmock.strict('../../src/utils.mjs', {
-    execa: {
-      execa: command => {
-        if (command === 'git') {
-          return { stdout: name }
-        }
-        return ''
-      },
-    },
-  })
-  const username = await getUsername()
-  equal(username, name)
-})
-
-test('getUsername from whoami', async () => {
-  const name = 'hansolo'
-  const { getUsername } = await esmock.strict('../../src/utils.mjs', {
-    execa: {
-      execa: command => {
-        if (command === 'whoami') {
-          return { stdout: name }
-        }
-        return ''
-      },
-    },
-  })
-  const username = await getUsername()
-  equal(username, name)
-})
-
-test('if getUsername from git failed, it tries whoim', async () => {
-  const name = 'lukeskywalker'
-
-  const { getUsername } = await esmock.strict('../../src/utils.mjs', {
-    execa: {
-      execa: command => {
-        if (command === 'git') {
-          throw new Error('git failed')
-        }
-        if (command === 'whoami') {
-          return { stdout: name }
-        }
-
-        return ''
-      },
-    },
-  })
-  const username = await getUsername()
-  equal(username, name)
-})
-
-test('if both git usern.ame and whoami fail, no username is set', async () => {
-  const { getUsername } = await esmock.strict('../../src/utils.mjs', {
-    execa: {
-      execa: command => {
-        if (command === 'git') {
-          throw new Error('git failed')
-        }
-        if (command === 'whoami') {
-          throw new Error('whoami failed')
-        }
-        return ''
-      },
-    },
-  })
-  const username = await getUsername()
-  equal(username, null)
-})
-
-test('getUsername - no username found', async () => {
-  const { getUsername } = await esmock.strict('../../src/utils.mjs', {
-    execa: {
-      execa: command => {
-        return ''
-      },
-    },
-  })
-  const username = await getUsername()
-  equal(username, null)
-})
-
-test('randomBetween', async () => {
-  const min = 1
-  const max = 10
-  const random = randomBetween(min, max)
-  equal(random >= min && random <= max, true)
-})
-
-test('sleep', async () => {
-  const start = Date.now()
-  await sleep(100)
-  const end = Date.now()
-  // We cannot assert the exact drift because timers
-  // are imprecise
-  equal(end - start >= 90, true)
-})
-
-test('getDependencyVersion', async () => {
-  const fastifyVersion = await getDependencyVersion('fastify')
-  // We cannot assert the exact version because it changes
-  equal(semver.valid(fastifyVersion), fastifyVersion)
-  equal(semver.gt(fastifyVersion, '4.10.0'), true)
-
-  const typescriptVersion = await getDependencyVersion('typescript')
-  // We cannot assert the exact version because it changes
-  equal(semver.valid(typescriptVersion), typescriptVersion)
-  equal(semver.gt(typescriptVersion, '5.0.0'), true)
-
-  const platformaticConfig = await getDependencyVersion('@platformatic/config')
-  // We cannot assert the exact version because it changes
-  equal(semver.valid(platformaticConfig), platformaticConfig)
-  equal(semver.gt(platformaticConfig, '1.0.0'), true)
-
-  const typesVersion = await getDependencyVersion('@types/node')
-  // We cannot assert the exact version because it changes
-  equal(semver.valid(typesVersion), typesVersion)
-  equal(semver.gt(typesVersion, '20.0.0'), true)
-
-  const unkownVersion = await getDependencyVersion('@types/npm')
-  equal(unkownVersion, undefined)
-})
-
-test('findDBConfigFile', async () => {
-  const tmpDir1 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const tmpDir2 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const config = join(tmpDir1, 'platformatic.db.yml')
-  await writeFile(config, 'TEST')
-  equal(await findDBConfigFile(tmpDir1), 'platformatic.db.yml')
-  equal(await findDBConfigFile(tmpDir2), undefined)
-  await safeRemove(tmpDir1)
-  await safeRemove(tmpDir2)
-})
-
-test('findServiceConfigFile', async () => {
-  const tmpDir1 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const tmpDir2 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const config = join(tmpDir1, 'platformatic.service.toml')
-  await writeFile(config, 'TEST')
-  equal(await findServiceConfigFile(tmpDir1), 'platformatic.service.toml')
-  equal(await findServiceConfigFile(tmpDir2), undefined)
-  await safeRemove(tmpDir1)
-  await safeRemove(tmpDir2)
-})
-
-test('findComposerConfigFile', async () => {
-  const tmpDir1 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const tmpDir2 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const config = join(tmpDir1, 'platformatic.composer.yml')
-  await writeFile(config, 'TEST')
-  equal(await findComposerConfigFile(tmpDir1), 'platformatic.composer.yml')
-  equal(await findComposerConfigFile(tmpDir2), undefined)
-  await safeRemove(tmpDir1)
-  await safeRemove(tmpDir2)
-})
-
-test('findRuntimeConfigFile', async () => {
-  const tmpDir1 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const tmpDir2 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const config = join(tmpDir1, 'platformatic.runtime.yml')
-  await writeFile(config, 'TEST')
-  equal(await findRuntimeConfigFile(tmpDir1), 'platformatic.runtime.yml')
-  equal(await findRuntimeConfigFile(tmpDir2), undefined)
-  await safeRemove(tmpDir1)
-  await safeRemove(tmpDir2)
-})
-
-test('isFileAccessible', async () => {
-  const tmpDir1 = await mkdtemp(join(tmpdir(), 'test-create-platformatic-'))
-  const config = join(tmpDir1, 'platformatic.db.yml')
-  await writeFile(config, 'TEST')
-  equal(await isFileAccessible(config), true)
-  const config2 = join(tmpDir1, 'platformatic2.db.yml')
-  equal(await isFileAccessible(config2), false)
-  await safeRemove(tmpDir1)
-})
-
-test('minimumSupportedNodeVersions', async () => {
-  equal(Array.isArray(minimumSupportedNodeVersions), true)
-  notEqual(minimumSupportedNodeVersions.length, 0)
-})
-
-test('isCurrentVersionSupported', async () => {
-  const { major, minor, patch } = semver.minVersion(minimumSupportedNodeVersions[0])
-  {
-    // major - 1 not supported
-    const nodeVersion = `${major - 1}.${minor}.${patch}`
-    const supported = isCurrentVersionSupported(nodeVersion)
-    equal(supported, false)
-  }
-  {
-    // minor - 1 not supported
-    const nodeVersion = `${major}.${minor - 1}.${patch}`
-    const supported = isCurrentVersionSupported(nodeVersion)
-    equal(supported, false)
-  }
-  {
-    // v16 more than minimum is supported
-    const supported = isCurrentVersionSupported(`${major}.${minor + 2}.${patch}`)
-    equal(supported, true)
-  }
-
-  // node version 20 test, to check greater and lesser major version
-  {
-    // v18.0.0 is not supported
-    const nodeVersion = '18.0.0'
-    const supported = isCurrentVersionSupported(nodeVersion)
-    equal(supported, false)
-  }
-  {
-    // v18.8.0 is supported
-    const nodeVersion = '18.8.0'
-    const supported = isCurrentVersionSupported(nodeVersion)
-    equal(supported, true)
-  }
-  {
-    // v20.5.1 is not supported
-    const supported = isCurrentVersionSupported('20.5.1')
-    equal(supported, false)
-  }
-  {
-    // v20.6.0 is supported
-    const nodeVersion = '20.6.0'
-    const supported = isCurrentVersionSupported(nodeVersion)
-    equal(supported, true)
-  }
-  {
-    // v19.0.0 is not supported
-    const supported = isCurrentVersionSupported('19.0.0')
-    equal(supported, false)
-  }
-  {
-    // v19.9.0 is not supported
-    const supported = isCurrentVersionSupported('19.9.0')
-    equal(supported, false)
-  }
-  for (const version of minimumSupportedNodeVersions) {
-    const supported = isCurrentVersionSupported(version)
-    equal(supported, true)
-  }
-})
-
-test('should convert service name to env prefix', async () => {
-  const expectations = {
-    'my-service': 'MY_SERVICE',
-    a: 'A',
-    MY_SERVICE: 'MY_SERVICE',
-    asderas123: 'ASDERAS123',
-  }
-
-  Object.entries(expectations).forEach(exp => {
-    const converted = convertServiceNameToPrefix(exp[0])
-    equal(exp[1], converted)
-  })
-})
-
-test('should add prefix to a key/value object', async () => {
-  const prefix = 'MY_PREFIX'
-  const env = {
-    PLT_HOSTNAME: 'myhost',
-    PORT: '3042',
-  }
-  deepEqual(addPrefixToEnv(env, prefix), {
-    MY_PREFIX_PLT_HOSTNAME: 'myhost',
-    MY_PREFIX_PORT: '3042',
-  })
-})